Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. factory-pattern-csharp
POMOC .NET

Wzorzec fabryczny w języku C# (jak działa dla programistów)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

Wzorzec fabryczny w języku C# to podejście strukturalne należące do kategorii wzorców projektowych. Wzorzec projektowy Factory Method w języku C# ma na celu rozwiązywanie problemów związanych z tworzeniem obiektów bez określania dokładnej klasy tworzącej obiekt, który zostanie utworzony.

Zasadniczo wzorzec fabryczny zajmuje się tworzeniem obiektów poprzez delegowanie tego zadania do konkretnej klasy, znanej jako klasa fabryczna. Dzięki temu system jest bardziej elastyczny i łatwiejszy w zarządzaniu, zwłaszcza przy wprowadzaniu nowych typów obiektów, ponieważ klasa fabryczna obsługuje proces tworzenia obiektów, zmniejszając zależność od klas konkretnych. Przyjrzyjmy się, jak można zaimplementować i wykorzystać wzorzec Factory Method, czyli wzorzec projektowy typu kreacyjnego w języku C#. Bibliotekę IronPDF PDF Generation Library omówimy później.

Podstawowa struktura wzorca metody fabrycznej

Główną ideą wzorca metody fabrycznej jest zdefiniowanie wspólnego interfejsu do tworzenia obiektów, przy jednoczesnym umożliwieniu podklasom zmiany typu tworzonych obiektów. Ten wzorzec obejmuje kilka kluczowych elementów:

  • Interfejs produktu: Określa strukturę obiektów tworzonych przez metodę fabryczną.
  • Konkretne klasy produktów: Implementują interfejs produktu.
  • Klasa Creator (klasa abstrakcyjna Creator): Deklaruje metodę fabryczną, która zwraca obiekt interfejsu produktu.
  • Concrete Creator: Modyfikuje metodę fabryczną w celu dostarczenia instancji konkretnego produktu.

Przykład: Fabryka pojazdów

Rozważmy scenariusz, w którym mamy różne rodzaje pojazdów, takie jak samochody osobowe i ciężarówki. Wykorzystamy wzorzec fabryczny do stworzenia fabryki pojazdów, która może tworzyć różne typy pojazdów na podstawie danych wprowadzonych przez użytkownika lub pliku konfiguracyjnego.

Krok 1: Zdefiniuj interfejs produktu

public interface IVehicle
{
    // Method to display information about the vehicle
    void DisplayInfo();
}
public interface IVehicle
{
    // Method to display information about the vehicle
    void DisplayInfo();
}
Public Interface IVehicle
	' Method to display information about the vehicle
	Sub DisplayInfo()
End Interface
$vbLabelText   $csharpLabel

Krok 2: Wdrożenie konkretnych produktów

public class Car : IVehicle
{
    // Displays Car specific information
    public void DisplayInfo()
    {
        Console.WriteLine("This is a Car.");
    }
}

public class Truck : IVehicle
{
    // Displays Truck specific information
    public void DisplayInfo()
    {
        Console.WriteLine("This is a Truck.");
    }
}
public class Car : IVehicle
{
    // Displays Car specific information
    public void DisplayInfo()
    {
        Console.WriteLine("This is a Car.");
    }
}

public class Truck : IVehicle
{
    // Displays Truck specific information
    public void DisplayInfo()
    {
        Console.WriteLine("This is a Truck.");
    }
}
Public Class Car
	Implements IVehicle

	' Displays Car specific information
	Public Sub DisplayInfo()
		Console.WriteLine("This is a Car.")
	End Sub
End Class

Public Class Truck
	Implements IVehicle

	' Displays Truck specific information
	Public Sub DisplayInfo()
		Console.WriteLine("This is a Truck.")
	End Sub
End Class
$vbLabelText   $csharpLabel

Krok 3: Utwórz klasę tworzącą abstrakcję

public abstract class VehicleFactory
{
    // Factory Method to create a vehicle instance
    public abstract IVehicle CreateVehicle(string type);
}
public abstract class VehicleFactory
{
    // Factory Method to create a vehicle instance
    public abstract IVehicle CreateVehicle(string type);
}
Public MustInherit Class VehicleFactory
	' Factory Method to create a vehicle instance
	Public MustOverride Function CreateVehicle(ByVal type As String) As IVehicle
End Class
$vbLabelText   $csharpLabel

Krok 4: Wdrożenie Concrete Creator

public class ConcreteVehicleFactory : VehicleFactory
{
    public override IVehicle CreateVehicle(string type)
    {
        // Create vehicle based on type
        switch (type.ToLower())
        {
            case "car": return new Car();
            case "truck": return new Truck();
            default: throw new ArgumentException("Invalid vehicle type");
        }
    }
}
public class ConcreteVehicleFactory : VehicleFactory
{
    public override IVehicle CreateVehicle(string type)
    {
        // Create vehicle based on type
        switch (type.ToLower())
        {
            case "car": return new Car();
            case "truck": return new Truck();
            default: throw new ArgumentException("Invalid vehicle type");
        }
    }
}
Public Class ConcreteVehicleFactory
	Inherits VehicleFactory

	Public Overrides Function CreateVehicle(ByVal type As String) As IVehicle
		' Create vehicle based on type
		Select Case type.ToLower()
			Case "car"
				Return New Car()
			Case "truck"
				Return New Truck()
			Case Else
				Throw New ArgumentException("Invalid vehicle type")
		End Select
	End Function
End Class
$vbLabelText   $csharpLabel

Krok 5: Wykorzystanie kodu klienta

class Program
{
    static void Main(string[] args)
    {
        // Create factory instance
        VehicleFactory factory = new ConcreteVehicleFactory();

        // Create a Car and display its info
        IVehicle car = factory.CreateVehicle("car");
        car.DisplayInfo();

        // Create a Truck and display its info
        IVehicle truck = factory.CreateVehicle("truck");
        truck.DisplayInfo();
    }
}
class Program
{
    static void Main(string[] args)
    {
        // Create factory instance
        VehicleFactory factory = new ConcreteVehicleFactory();

        // Create a Car and display its info
        IVehicle car = factory.CreateVehicle("car");
        car.DisplayInfo();

        // Create a Truck and display its info
        IVehicle truck = factory.CreateVehicle("truck");
        truck.DisplayInfo();
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create factory instance
		Dim factory As VehicleFactory = New ConcreteVehicleFactory()

		' Create a Car and display its info
		Dim car As IVehicle = factory.CreateVehicle("car")
		car.DisplayInfo()

		' Create a Truck and display its info
		Dim truck As IVehicle = factory.CreateVehicle("truck")
		truck.DisplayInfo()
	End Sub
End Class
$vbLabelText   $csharpLabel

W powyższym przykładzie klasa VehicleFactory pełni rolę abstrakcyjnego kreatora, a klasa ConcreteVehicleFactory jest konkretnym kreatorem, który implementuje metodę fabryczną CreateVehicle. Ta metoda decyduje, jaki typ pojazdu utworzyć na podstawie otrzymanych danych wejściowych. Kod klienta wykorzystuje następnie fabrykę do tworzenia instancji różnych pojazdów, co sprzyja luźnemu powiązaniu między logiką tworzenia obiektów a kodem klienta.

Wzorzec fabryczny w języku C# (jak działa dla programistów): Rysunek 1 – Wynik zastosowania wzorca projektowego fabrycznego

Zalety stosowania wzorca fabrycznego

Wzorzec fabryczny oferuje kilka zalet, zwłaszcza w złożonych systemach:

  • Luźne sprzężenie: Kod klienta współdziała z interfejsami lub klasami abstrakcyjnymi zamiast z konkretnymi klasami produktów. Wynikiem tego jest projekt, który jest bardziej elastyczny i łatwiejszy do modyfikacji.
  • Oprogramowanie obiektowe wielokrotnego użytku: Wzorzec fabryczny sprzyja ponownemu wykorzystaniu kodu, ponieważ oddziela logikę tworzenia obiektów od systemu, ułatwiając jego utrzymanie i rozbudowę.
  • Elastyczność w tworzeniu obiektów: Metoda fabryczna pozwala na różne implementacje tworzenia obiektów, które można wybierać w czasie wykonywania. Jest to szczególnie przydatne w sytuacjach, w których typ wymaganych obiektów może się różnić w zależności od czynników zewnętrznych.

IronPDF: Rozwiązanie PDF dla platformy .NET

Wzorzec Factory w C# (jak to działa dla programistów): Rysunek 2 – IronPDF

IronPDF to biblioteka zaprojektowana dla platformy .NET, pomagająca programistom w łatwym tworzeniu, edytowaniu i manipulowaniu plikami PDF bezpośrednio z HTML, CSS, obrazów i JavaScript, bez konieczności zagłębiania się w skomplikowane API do generowania plików PDF. Jej główną zaletą jest możliwość szybkiego i bardzo dokładnego przekształcania treści internetowych w dokumenty PDF dzięki wykorzystaniu silnika renderującego opartego na przeglądarce Chrome.

Kluczowe funkcje obejmują generowanie plików PDF z ciągów znaków HTML lub adresów URL, renderowanie stron internetowych jako plików PDF w locie oraz możliwość pracy między innymi z aplikacjami formularzowymi, aplikacjami serwerowymi i bezpiecznymi intranetami. Jego wydajność jest zoptymalizowana pod kątem efektywności, z możliwością operacji asynchronicznych, niestandardowego logowania oraz obszernej dokumentacji, która pomoże Ci szybko rozpocząć pracę.

IronPDF wyróżnia się w konwersji HTML do PDF, zapewniając precyzyjne zachowanie oryginalnych układów i stylów. Idealnie nadaje się do tworzenia plików PDF z treści internetowych, takich jak raporty, faktury i dokumentacja. Dzięki obsłudze plików HTML, adresów URL i surowych ciągów znaków HTML, IronPDF z łatwością tworzy wysokiej jakości dokumenty PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        // Initialize a Pdf Renderer with a Chrome Rendering Engine
        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)
    {
        // Initialize a Pdf Renderer with a Chrome Rendering Engine
        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");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Initialize a Pdf Renderer with a Chrome Rendering Engine
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Przykład kodu

Aby zilustrować, w jaki sposób IronPDF można zintegrować z wzorcem fabrycznym, stwórzmy uproszczony przykład. Wzorzec fabryczny to rodzaj wzorca projektowego tworzenia, który oferuje sposób na tworzenie konkretnych produktów lub obiektów w ramach klasy nadrzędnej, pozwalając podklasom na modyfikowanie konkretnych obiektów, które są wytwarzane. Doskonale wpisuje się to w tworzenie różnych typów dokumentów PDF w oparciu o konkretne potrzeby, np. na podstawie ciągów HTML, adresów URL lub plików.

Stworzymy interfejs o nazwie IPdfCreator, który definiuje metodę tworzenia plików PDF, a następnie zaimplementujemy różne klasy fabryczne, które tworzą pliki PDF na różne sposoby przy użyciu IronPDF.

Krok 1: Zdefiniuj interfejs IPdfCreator

Ten interfejs deklaruje metodę CreatePdf, którą zaimplementują wszystkie konkretne fabryki.

public interface IPdfCreator
{
    // Method responsible for creating a PDF
    void CreatePdf(string source);
}
public interface IPdfCreator
{
    // Method responsible for creating a PDF
    void CreatePdf(string source);
}
Public Interface IPdfCreator
	' Method responsible for creating a PDF
	Sub CreatePdf(ByVal source As String)
End Interface
$vbLabelText   $csharpLabel

Krok 2: Wdrożenie fabryk konkretów

W tym miejscu definiujemy dwa konkretne wdrożenia IPdfCreator: jedno do tworzenia plików PDF z ciągów znaków HTML, a drugie z adresów URL.

public class HtmlStringPdfCreator : IPdfCreator
{
    // Creates a PDF from an HTML string
    public void CreatePdf(string htmlString)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlString);
        pdf.SaveAs("HtmlStringPdf.pdf");
    }
}

// Create PDF from a given URL
public class UrlPdfCreator : IPdfCreator
{
    public void CreatePdf(string url)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("UrlPdf.pdf");
    }
}
public class HtmlStringPdfCreator : IPdfCreator
{
    // Creates a PDF from an HTML string
    public void CreatePdf(string htmlString)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlString);
        pdf.SaveAs("HtmlStringPdf.pdf");
    }
}

// Create PDF from a given URL
public class UrlPdfCreator : IPdfCreator
{
    public void CreatePdf(string url)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("UrlPdf.pdf");
    }
}
Public Class HtmlStringPdfCreator
	Implements IPdfCreator

	' Creates a PDF from an HTML string
	Public Sub CreatePdf(ByVal htmlString As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlString)
		pdf.SaveAs("HtmlStringPdf.pdf")
	End Sub
End Class

' Create PDF from a given URL
Public Class UrlPdfCreator
	Implements IPdfCreator

	Public Sub CreatePdf(ByVal url As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderUrlAsPdf(url)
		pdf.SaveAs("UrlPdf.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Krok 3: Korzystanie z Factory

W swojej aplikacji możesz teraz używać tych fabryk do tworzenia dokumentów PDF z różnych źródeł, nie martwiąc się o szczegóły procesu tworzenia plików PDF.

class Program
{
    static void Main(string[] args)
    {
        // Add your IronPDF license key
        License.LicenseKey = "License-Key";

        // Create PDF from HTML string
        IPdfCreator htmlPdfCreator = new HtmlStringPdfCreator();
        htmlPdfCreator.CreatePdf("<h1>Hello, World!</h1>");

        // Create PDF from URL
        IPdfCreator urlPdfCreator = new UrlPdfCreator();
        urlPdfCreator.CreatePdf("http://example.com");
    }
}
class Program
{
    static void Main(string[] args)
    {
        // Add your IronPDF license key
        License.LicenseKey = "License-Key";

        // Create PDF from HTML string
        IPdfCreator htmlPdfCreator = new HtmlStringPdfCreator();
        htmlPdfCreator.CreatePdf("<h1>Hello, World!</h1>");

        // Create PDF from URL
        IPdfCreator urlPdfCreator = new UrlPdfCreator();
        urlPdfCreator.CreatePdf("http://example.com");
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Add your IronPDF license key
		License.LicenseKey = "License-Key"

		' Create PDF from HTML string
		Dim htmlPdfCreator As IPdfCreator = New HtmlStringPdfCreator()
		htmlPdfCreator.CreatePdf("<h1>Hello, World!</h1>")

		' Create PDF from URL
		Dim urlPdfCreator As IPdfCreator = New UrlPdfCreator()
		urlPdfCreator.CreatePdf("http://example.com")
	End Sub
End Class
$vbLabelText   $csharpLabel

W tym kontekście HtmlStringPdfCreator i UrlPdfCreator to konkretne fabryki, które generują pliki PDF. Klasa Program, pełniąca rolę klienta, korzysta z tych fabryk bez konieczności znajomości skomplikowanych szczegółów dotyczących generowania plików PDF na podstawie ciągów znaków HTML lub adresów URL. Takie podejście zapewnia elastyczność, ponieważ można wprowadzać nowe sposoby tworzenia plików PDF (np. z plików lub strumieni) po prostu poprzez dodanie kolejnych fabryk implementujących interfejs IPdfCreator, zgodnie z zasadą otwartości i zamkniętości w projektowaniu obiektowym.

Wynik

Poniższe zrzuty ekranu przedstawiają wynik działania kodu:

Wzorzec fabryczny C# (jak działa dla programistów): Rysunek 3 – Wzorzec projektowy fabryczny – plik PDF

Wzorzec Factory w C# (jak działa dla programistów): Rysunek 4 – Wynik metody BaseFactory

Wnioski

Wzorzec Factory w języku C# (jak działa dla programistów): Rysunek 5 – Licencjonowanie

Wzorzec fabryczny w języku C# zapewnia strukturę do zarządzania tworzeniem obiektów, dzięki czemu projekt oprogramowania jest łatwiejszy w utrzymaniu i rozbudowie. Wykorzystując konkretne klasy do implementacji abstrakcyjnej fabryki i delegowania logiki tworzenia, programiści mogą tworzyć systemy, które łatwiej dostosować i rozbudować. Niezależnie od tego, czy mamy do czynienia z kilkoma klasami, czy z systemem o złożonych zależnościach, wzorzec fabryczny oferuje ustrukturyzowane podejście do precyzyjnego tworzenia obiektów klas. Jest to szczególnie przydatne w sytuacjach, w których typ tworzonych obiektów może się różnić w zależności od danych wprowadzonych przez użytkownika, konfiguracji lub stanu aplikacji.

IronPDF oferuje bezpłatną wersję próbną IronPDF na początek, a opcje licencji zaczynają się od liteLicense, co jest rozwiązaniem dla programistów pragnących zintegrować funkcje PDF ze swoimi aplikacjami .NET.

Często Zadawane Pytania

Jak można zastosować wzorzec fabryczny w programowaniu w języku C#?

Wzorce fabryczne można zastosować w programowaniu w języku C# poprzez utworzenie klasy fabrycznej, która zarządza instancjonowaniem obiektów. Takie podejście pozwala programistom zdefiniować interfejs do tworzenia obiektów, ale umożliwia podklasom zmianę typu tworzonych obiektów, co sprzyja luźnemu sprzężeniu i elastyczności systemu.

Jaką rolę odgrywa wzorzec fabryczny w projektowaniu oprogramowania?

Wzorzec fabryczny odgrywa kluczową rolę w projektowaniu oprogramowania, zapewniając sposób delegowania instancjonowania obiektów do klasy fabrycznej. Pomaga to w oddzieleniu logiki tworzenia od logiki biznesowej, dzięki czemu system jest łatwiejszy w zarządzaniu i rozbudowie.

W jaki sposób programiści mogą wykorzystać IronPDF do tworzenia dokumentów PDF w języku C#?

Programiści mogą używać IronPDF do tworzenia dokumentów PDF w języku C#, korzystając z silnika renderującego opartego na przeglądarce Chrome. Dzięki metodom takim jak RenderHtmlAsPdf lub RenderUrlAsPdf ciągi znaków HTML lub strony internetowe można bez wysiłku konwertować na wysokiej jakości dokumenty PDF.

Jakie są zalety korzystania z biblioteki PDF dla platformy .NET, takiej jak IronPDF?

Korzystanie z biblioteki .NET do obsługi plików PDF, takiej jak IronPDF, oferuje wiele korzyści, w tym możliwość tworzenia, edytowania i manipulowania plikami PDF na podstawie różnych danych wejściowych, takich jak HTML, CSS, obrazy i JavaScript. Obsługuje operacje asynchroniczne i pomaga zachować oryginalny układ oraz style treści internetowej w plikach PDF.

W jaki sposób wzorzec fabryczny może usprawnić generowanie dokumentów PDF?

Wzorzec Factory usprawnia generowanie dokumentów PDF, umożliwiając programistom zdefiniowanie wspólnego interfejsu do tworzenia plików PDF z różnych źródeł, takich jak ciągi HTML, adresy URL lub pliki. Pozwala to na dodawanie nowych typów plików PDF bez zmiany istniejącego kodu, zgodnie z zasadą otwartości i zamkniętości.

W jakich sytuacjach wzorzec Factory jest najbardziej przydatny?

Wzorzec fabryczny jest najbardziej przydatny w sytuacjach, gdy system musi dynamicznie obsługiwać tworzenie obiektów w oparciu o dane wprowadzane przez użytkownika lub konfigurację. Jest to szczególnie korzystne w aplikacjach, które wymagają częstych zmian lub rozszerzeń procesu tworzenia obiektów.

Jakie znaczenie ma wzorzec fabryczny dla zachowania elastyczności oprogramowania?

Znaczenie wzorca fabrycznego dla zachowania elastyczności oprogramowania polega na jego zdolności do oddzielenia tworzenia obiektów od logiki biznesowej. Pozwala to programistom na wprowadzanie nowych typów obiektów bez modyfikowania istniejącego kodu, zachowując w ten sposób elastyczną i rozszerzalną architekturę.

W jaki sposób IronPDF wspiera wzorzec fabryczny podczas tworzenia dokumentów?

IronPDF obsługuje wzorzec fabryczny (Factory Pattern) w tworzeniu dokumentów, umożliwiając programistom implementację tego wzorca poprzez swoje interfejsy i metody. Na przykład, używając ChromePdfRenderer z różnymi typami danych wejściowych, programiści mogą tworzyć różne formularze dokumentów PDF bez zmiany podstawowej logiki tworzenia.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
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ą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie