¿Qué son los métodos virtuales en C#?

Los métodos virtuales en C# son métodos que incluyen una implementación predeterminada, pero pueden ser sobreescritos por clases derivadas para proporcionar comportamientos específicos, fomentando la flexibilidad en el diseño del código.

¿Cómo puedo utilizar IronPDF para convertir HTML a PDF en C#?

Puedes usar el método RenderHtmlAsPdf de IronPDF para convertir cadenas HTML en PDFs. Esto te permite mantener el diseño y los estilos de tu contenido HTML en el documento PDF resultante.

¿Cuál es la diferencia entre los métodos virtuales y abstractos en C#?

Los métodos virtuales tienen una implementación predeterminada y pueden ser opcionalmente sobreescritos en clases derivadas, mientras que los métodos abstractos no tienen implementación y deben ser sobreescritos en clases derivadas.

¿Cómo puede IronPDF ayudar a generar PDFs en aplicaciones .NET?

IronPDF es una biblioteca potente que facilita la generación, edición y lectura de documentos PDF dentro de aplicaciones .NET. Permite la creación de PDFs a partir de contenido HTML, asegurando que los diseños se mantengan.

¿Qué es un método abstracto en C#?

Un método abstracto es un método que se declara sin una implementación en una clase abstracta y debe ser implementado en cualquier clase derivada no abstracta, asegurando un comportamiento específico en las clases derivadas.

¿Puede una clase en C# tener métodos virtuales y abstractos?

Sí, una clase puede contener tanto métodos virtuales como abstractos. Los métodos virtuales proporcionan una implementación predeterminada, mientras que los métodos abstractos requieren una implementación explícita en las clases derivadas.

¿Cómo se sobreescribe un método virtual en una clase derivada?

Para sobreescribir un método virtual en una clase derivada, se utiliza la palabra clave override seguida de la firma del método, permitiendo una implementación nueva o extendida.

¿Cuándo deben los desarrolladores usar métodos virtuales en C#?

Los desarrolladores deben usar métodos virtuales cuando se necesita un comportamiento predeterminado que pueda ser opcionalmente sobreescrito por clases derivadas, facilitando el polimorfismo y la reutilización del código.

¿Cuáles son los beneficios de usar IronPDF en proyectos de C#?

IronPDF mejora los proyectos de C# al proporcionar capacidades robustas de generación y manipulación de PDF, como convertir HTML a PDF y mantener la integridad del diseño de los documentos.

¿Cómo asegura IronPDF que los diseños de documentos PDF se mantengan?

IronPDF convierte contenido HTML en PDFs al renderizar con precisión cadenas, archivos o URLs de HTML en formato PDF, asegurando que todos los estilos y diseños se conserven en la salida.

La Biblioteca PDF de C#

Explore IronPDF Prueba gratis

HTML a PDF

Online Demo Ver Todos los Ejemplos de Código %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

Install-Package IronPdf

ACTUALIZACIONES PARA DESARROLLADORES

C# Vitrual Vs Abstract (Cómo Funciona para Desarrolladores)

Jacob Mellor

Updated: 23 de abril de 2026

En C#, los métodos virtuales pueden ser sobrescritos en clases derivadas, mientras que los métodos abstractos deben ser sobrescritos en clases derivadas. Esto permite un comportamiento flexible y habilita el polimorfismo en la programación orientada a objetos. Estos dos conceptos permiten flexibilidad y reutilización en la programación orientada a objetos. Este artículo explica los detalles de los métodos abstractos y virtuales, proporcionando ejemplos claros y enfocándose en sus usos prácticos en la programación. También exploraremos las capacidades y casos de uso de IronPDF más adelante en el artículo.

Clases y métodos abstractos

Una clase abstracta es un tipo especial de clase que no puede ser instanciada directamente. En su lugar, sirve como un modelo para otras clases. Una clase abstracta puede contener métodos abstractos, que son métodos declarados en la clase abstracta pero deben implementarse en las clases derivadas concretas.

public abstract class Vehicle
{
    // Abstract method to be implemented in non-abstract child class
    public abstract void DisplayInfo();
}

public abstract class Vehicle
{
    // Abstract method to be implemented in non-abstract child class
    public abstract void DisplayInfo();
}

Public MustInherit Class Vehicle
	' Abstract method to be implemented in non-abstract child class
	Public MustOverride Sub DisplayInfo()
End Class

Public MustInherit Class Vehicle
	' Abstract method to be implemented in non-abstract child class
	Public MustOverride Sub DisplayInfo()
End Class

En este ejemplo, la clase Vehicle es abstracta, y DisplayInfo es un método abstracto. El método DisplayInfo no tiene ninguna implementación en la clase Vehicle. Obliga a la clase derivada a proporcionar su propia definición de este método.

Métodos virtuales

Los métodos virtuales son métodos en una clase base que tienen una implementación por defecto pero pueden ser sobrescritos en clases derivadas. La palabra clave virtual se usa para declarar un método como virtual. Las clases derivadas usan la palabra clave override para proporcionar una implementación específica del método, lo que ayuda a comprender cómo una clase hija puede sobrescribir el método virtual de su padre.

// Non-abstract class
public class Animal
{
    // Virtual method with a default implementation
    public virtual void Speak()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

// Non-abstract class
public class Animal
{
    // Virtual method with a default implementation
    public virtual void Speak()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

' Non-abstract class
Public Class Animal
	' Virtual method with a default implementation
	Public Overridable Sub Speak()
		Console.WriteLine("Some generic animal sound")
	End Sub
End Class

' Non-abstract class
Public Class Animal
	' Virtual method with a default implementation
	Public Overridable Sub Speak()
		Console.WriteLine("Some generic animal sound")
	End Sub
End Class

Aquí, la clase Animal tiene un método virtual Speak con una implementación por defecto. Las clases derivadas pueden sobrescribir el método para proporcionar un sonido específico del animal usando la palabra clave override.

Combinación de métodos virtuales y abstractos

Una clase puede tener tanto métodos abstractos como virtuales. Los métodos abstractos no tienen una implementación y deben ser sobrescritos en clases derivadas, mientras que los métodos virtuales tienen una implementación por defecto que las clases derivadas pueden sobrescribir opcionalmente.

Considere un escenario donde está construyendo un sistema que modela diferentes tipos de vehículos, cada uno con su propia forma de mostrar información. Así es como puede usar métodos abstractos y virtuales:

public abstract class Vehicle
{
    // Abstract method
    public abstract void DisplayInfo();

    // Virtual method
    public virtual void StartEngine()
    {
        Console.WriteLine("Engine started with default configuration.");
    }
}

public abstract class Vehicle
{
    // Abstract method
    public abstract void DisplayInfo();

    // Virtual method
    public virtual void StartEngine()
    {
        Console.WriteLine("Engine started with default configuration.");
    }
}

Public MustInherit Class Vehicle
	' Abstract method
	Public MustOverride Sub DisplayInfo()

	' Virtual method
	Public Overridable Sub StartEngine()
		Console.WriteLine("Engine started with default configuration.")
	End Sub
End Class

Public MustInherit Class Vehicle
	' Abstract method
	Public MustOverride Sub DisplayInfo()

	' Virtual method
	Public Overridable Sub StartEngine()
		Console.WriteLine("Engine started with default configuration.")
	End Sub
End Class

En esta clase Vehicle, DisplayInfo es un método abstracto, obligando a todas las clases derivadas a implementar su forma de mostrar información. StartEngine, sin embargo, proporciona una forma por defecto de arrancar el motor, la cual puede ser sobrescrita por una clase heredada si es necesario.

Ejemplo con clases derivadas

Ahora, definamos una clase Car, una clase hija no abstracta que hereda de Vehicle e implementa el método abstracto mientras opcionalmente anula el método virtual:

public class Car : Vehicle
{
    // Override the abstract method
    public override void DisplayInfo()
    {
        Console.WriteLine("This is a car.");
    }

    // Override the virtual method
    public override void StartEngine()
    {
        Console.WriteLine("Car engine started with custom settings.");
    }
}

public class Car : Vehicle
{
    // Override the abstract method
    public override void DisplayInfo()
    {
        Console.WriteLine("This is a car.");
    }

    // Override the virtual method
    public override void StartEngine()
    {
        Console.WriteLine("Car engine started with custom settings.");
    }
}

Public Class Car
	Inherits Vehicle

	' Override the abstract method
	Public Overrides Sub DisplayInfo()
		Console.WriteLine("This is a car.")
	End Sub

	' Override the virtual method
	Public Overrides Sub StartEngine()
		Console.WriteLine("Car engine started with custom settings.")
	End Sub
End Class

Public Class Car
	Inherits Vehicle

	' Override the abstract method
	Public Overrides Sub DisplayInfo()
		Console.WriteLine("This is a car.")
	End Sub

	' Override the virtual method
	Public Overrides Sub StartEngine()
		Console.WriteLine("Car engine started with custom settings.")
	End Sub
End Class

Aquí, la clase Car proporciona implementaciones específicas tanto para el método abstracto DisplayInfo como para el método virtual StartEngine.

Diferencias y cuándo utilizarlas

Utilice métodos abstractos cuando todas las clases derivadas deben proporcionar su propia implementación de un método.
Utilice métodos virtuales cuando las clases derivadas deberían tener la opción de sobrescribir un por defecto o proporcionar comportamientos adicionales.

Los métodos abstractos y virtuales son características poderosas en C# que le permiten escribir código más mantenible y reutilizable. Definiendo métodos en una clase base como abstractos o virtuales, puede dictar qué métodos deben ser sobrescritos en clases derivadas y qué métodos pueden ser sobrescritos opcionalmente para modificar o extender el comportamiento por defecto.

Anulación de métodos virtuales

Sobrescribir métodos virtuales en clases derivadas permite un comportamiento personalizado mientras se retiene la opción de llamar a la implementación de la clase base. Esto se logra usando la palabra clave base.

Ejemplo de sobreescritura y llamada a implementación base

public class ElectricCar : Car
{
    // Override the StartEngine method
    public override void StartEngine()
    {
        base.StartEngine(); // Call the base class implementation
        Console.WriteLine("Electric car engine started with energy-saving mode.");
    }
}

public class ElectricCar : Car
{
    // Override the StartEngine method
    public override void StartEngine()
    {
        base.StartEngine(); // Call the base class implementation
        Console.WriteLine("Electric car engine started with energy-saving mode.");
    }
}

Public Class ElectricCar
	Inherits Car

	' Override the StartEngine method
	Public Overrides Sub StartEngine()
		MyBase.StartEngine() ' Call the base class implementation
		Console.WriteLine("Electric car engine started with energy-saving mode.")
	End Sub
End Class

Public Class ElectricCar
	Inherits Car

	' Override the StartEngine method
	Public Overrides Sub StartEngine()
		MyBase.StartEngine() ' Call the base class implementation
		Console.WriteLine("Electric car engine started with energy-saving mode.")
	End Sub
End Class

En este ejemplo, ElectricCar, que es una clase hija de Car, anula el método StartEngine heredado de su clase madre. Llama a la implementación de la clase base y agrega un comportamiento adicional específico de los autos eléctricos.

Implementación de clases abstractas y no abstractas

Es esencial entender las diferencias prácticas y aplicaciones de las clases abstractas y no abstractas en el desarrollo de software. Las clases abstractas sirven como una plantilla para otras clases, mientras que las clases no abstractas se utilizan para instanciar objetos. La elección entre usar una clase abstracta y una clase no abstracta depende de si necesita crear una clase base que no debe ser instanciada por sí sola.

IronPDF: Biblioteca PDF de C#

C# Virtual Vs Abstract (Cómo funciona para desarrolladores): Figura 1 - IronPDF

IronPDF es una biblioteca PDF integral diseñada para generar, editar y leer documentos PDF directamente dentro de aplicaciones .NET. Esta herramienta se destaca por su capacidad para crear PDFs directamente desde cadenas, archivos y URLs de HTML. Los desarrolladores pueden crear, modificar y extraer contenido de PDF programáticamente en proyectos de C#. Exploremos un ejemplo de IronPDF en el contexto de nuestro artículo.

La capacidad principal de IronPDF es convertir HTML a PDF, asegurando que los diseños y estilos se conserven. Esta herramienta es excelente para crear PDFs desde contenido web para informes, facturas y documentación. Admite la conversión de archivos HTML, URLs y cadenas HTML a archivos PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 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");
        
        // 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");
        
        // 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();

        // 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");
        
        // 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");
        
        // Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' 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")

        ' 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")

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

Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' 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")

        ' 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")

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

Ejemplo de código

Aquí hay un ejemplo de código real sencillo para ilustrar el uso de las palabras clave virtual y abstract en el contexto de extender las funcionalidades de IronPDF:

public abstract class PdfReportGenerator
{
    // Use abstract method to force derived classes to implement their custom PDF generation logic
    public abstract void GenerateReport(string filePath);

    // A virtual function allows derived classes to override the default implementation of PDF setup
    public virtual void SetupPdfGenerator()
    {
        // Default PDF setup logic that can be overridden by derived classes
        IronPdf.Installation.TempFolderPath = @"F:\TempPdfFiles";
    }
}

public class MonthlyReportGenerator : PdfReportGenerator
{
    // Override abstract method to provide specific implementation
    public override void GenerateReport(string filePath)
    {
        var pdf = new ChromePdfRenderer();
        pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath);
    }

    // Optionally override the virtual method to customize the setup
    public override void SetupPdfGenerator()
    {
        base.SetupPdfGenerator();
        // Additional setup logic specific to monthly reports
        IronPdf.Installation.TempFolderPath = @"F:\MonthlyReports";
    }
}

class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        PdfReportGenerator reportGenerator = new MonthlyReportGenerator();
        reportGenerator.SetupPdfGenerator();
        reportGenerator.GenerateReport(@"F:\MonthlyReports\MonthlyReport.pdf");
        Console.WriteLine("Report generated successfully.");
    }
}

public abstract class PdfReportGenerator
{
    // Use abstract method to force derived classes to implement their custom PDF generation logic
    public abstract void GenerateReport(string filePath);

    // A virtual function allows derived classes to override the default implementation of PDF setup
    public virtual void SetupPdfGenerator()
    {
        // Default PDF setup logic that can be overridden by derived classes
        IronPdf.Installation.TempFolderPath = @"F:\TempPdfFiles";
    }
}

public class MonthlyReportGenerator : PdfReportGenerator
{
    // Override abstract method to provide specific implementation
    public override void GenerateReport(string filePath)
    {
        var pdf = new ChromePdfRenderer();
        pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath);
    }

    // Optionally override the virtual method to customize the setup
    public override void SetupPdfGenerator()
    {
        base.SetupPdfGenerator();
        // Additional setup logic specific to monthly reports
        IronPdf.Installation.TempFolderPath = @"F:\MonthlyReports";
    }
}

class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        PdfReportGenerator reportGenerator = new MonthlyReportGenerator();
        reportGenerator.SetupPdfGenerator();
        reportGenerator.GenerateReport(@"F:\MonthlyReports\MonthlyReport.pdf");
        Console.WriteLine("Report generated successfully.");
    }
}

Public MustInherit Class PdfReportGenerator
	' Use abstract method to force derived classes to implement their custom PDF generation logic
	Public MustOverride Sub GenerateReport(ByVal filePath As String)

	' A virtual function allows derived classes to override the default implementation of PDF setup
	Public Overridable Sub SetupPdfGenerator()
		' Default PDF setup logic that can be overridden by derived classes
		IronPdf.Installation.TempFolderPath = "F:\TempPdfFiles"
	End Sub
End Class

Public Class MonthlyReportGenerator
	Inherits PdfReportGenerator

	' Override abstract method to provide specific implementation
	Public Overrides Sub GenerateReport(ByVal filePath As String)
		Dim pdf = New ChromePdfRenderer()
		pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath)
	End Sub

	' Optionally override the virtual method to customize the setup
	Public Overrides Sub SetupPdfGenerator()
		MyBase.SetupPdfGenerator()
		' Additional setup logic specific to monthly reports
		IronPdf.Installation.TempFolderPath = "F:\MonthlyReports"
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim reportGenerator As PdfReportGenerator = New MonthlyReportGenerator()
		reportGenerator.SetupPdfGenerator()
		reportGenerator.GenerateReport("F:\MonthlyReports\MonthlyReport.pdf")
		Console.WriteLine("Report generated successfully.")
	End Sub
End Class

Public MustInherit Class PdfReportGenerator
	' Use abstract method to force derived classes to implement their custom PDF generation logic
	Public MustOverride Sub GenerateReport(ByVal filePath As String)

	' A virtual function allows derived classes to override the default implementation of PDF setup
	Public Overridable Sub SetupPdfGenerator()
		' Default PDF setup logic that can be overridden by derived classes
		IronPdf.Installation.TempFolderPath = "F:\TempPdfFiles"
	End Sub
End Class

Public Class MonthlyReportGenerator
	Inherits PdfReportGenerator

	' Override abstract method to provide specific implementation
	Public Overrides Sub GenerateReport(ByVal filePath As String)
		Dim pdf = New ChromePdfRenderer()
		pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath)
	End Sub

	' Optionally override the virtual method to customize the setup
	Public Overrides Sub SetupPdfGenerator()
		MyBase.SetupPdfGenerator()
		' Additional setup logic specific to monthly reports
		IronPdf.Installation.TempFolderPath = "F:\MonthlyReports"
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim reportGenerator As PdfReportGenerator = New MonthlyReportGenerator()
		reportGenerator.SetupPdfGenerator()
		reportGenerator.GenerateReport("F:\MonthlyReports\MonthlyReport.pdf")
		Console.WriteLine("Report generated successfully.")
	End Sub
End Class

En este ejemplo de implementación personalizada, PdfReportGenerator es una clase abstracta que define un contrato para generar informes PDF con un método para generar el informe y un método virtual para la configuración que puede ser opcionalmente sobrescrito. MonthlyReportGenerator es una implementación concreta que proporciona los detalles para generar un informe mensual y personaliza la configuración sobrescribiendo el método virtual.

C# Virtual Vs Abstract (Cómo funciona para desarrolladores): Figura 2 - Resultado del informe

Conclusión

Entender y usar métodos virtuales y abstractos efectivamente puede mejorar significativamente su programación en C#. Recuerde, los métodos abstractos requieren que una clase derivada proporcione una implementación, mientras que los métodos virtuales permiten una sobrescritura opcional de una implementación por defecto. La biblioteca IronPDF ofrece una prueba gratuita y opciones de licencia, con licencias a partir de $999, proporcionando una solución completa para tus necesidades de PDF.

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.

...