Herencia en C# (Cómo funciona para los desarrolladores)

Introducción

Una de las principales características de C#, Herenciaes conocido por su fuerte apoyo a la programación orientada a objetos. (OOP) principios. Es esencial para escribir código escalable y eficaz. Este post explorará el tema de la herencia en C# haciendo hincapié en los usos reales de IronPDF una potente biblioteca que facilita el manejo de archivos PDF en programas C#.

Cómo utilizar C# Herencia

1. Crear un nuevo proyecto de consola C
2. Crear una clase base con algunos métodos.
3. Escribir una nueva clase derivada y heredar una clase.
4. Llamar a la función/Método que está disponible en una clase base.
5. Procesar la operación y Desechar el objeto.

Herencia en C#: Una visi&oacuten general

Una idea clave en la programación orientada a objetos (OOP) es la herencia, que permite a una clase (la derivada o subclase) adoptar rasgos y características de otra clase (la base o superclase). En C#, la herencia se consigue poniendo el nombre de la clase base después del: (colon) símbolo.

Herencia única

Una clase puede heredar de una sola clase base en C#, ya que se admite una única herencia. Cuando se desea que una clase derivada aumente la capacidad de una única clase base, se utiliza el tipo más básico de herencia: la herencia compuesta.

class Animal { /* Base/ Parent class */ }
class Dog : Animal { /* Derived class */ }

class Animal { /* Base/ Parent class */ }
class Dog : Animal { /* Derived class */ }

Friend Class Animal
End Class
Friend Class Dog
	Inherits Animal

End Class

Herencia jerárquica

Varias clases que comparten una clase base son heredadas por ellas en un esquema de herencia jerárquica. Que es una clase de base única heredada por múltiples clases derivadas. Puede haber otras características exclusivas de cada clase derivada en función de su finalidad.

class Animal { /* Base class */ }
class Dog : Animal { /* Derived class */ }
class Wolf : Animal { /* Derived class */ }

class Animal { /* Base class */ }
class Dog : Animal { /* Derived class */ }
class Wolf : Animal { /* Derived class */ }

Friend Class Animal
End Class
Friend Class Dog
	Inherits Animal

End Class
Friend Class Wolf
	Inherits Animal

End Class

Herencia multinivel

Una clase funciona a la vez como clase base y como clase derivada hereda en la herencia multinivel. Como resultado, se forma una cadena de herencia, en la que cada clase amplía las características de su predecesora.

class Animal { /* Base class */ }
class Mammal : Animal { /* Derived class */ }
class Dog : Mammal { /* Derived class  */ }

class Animal { /* Base class */ }
class Mammal : Animal { /* Derived class */ }
class Dog : Mammal { /* Derived class  */ }

Friend Class Animal
End Class
Friend Class Mammal
	Inherits Animal

End Class
Friend Class Dog
	Inherits Mammal

End Class

Herencia de interfaces

Una clase en C# puede implementar una o más interfaces y heredar de una única clase base. Esto permite a una clase heredar la implementación de métodos descritos en interfaces, consiguiendo así un tipo de herencia múltiple.

interface ILogger
{
    void Log(string message);
}
class ConsoleLogger : ILogger //clase de niño
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}
class FileLogger : ILogger
{
    public void Log(string message)
    {
        //  Registrar en archivo
    }
}

interface ILogger
{
    void Log(string message);
}
class ConsoleLogger : ILogger //clase de niño
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}
class FileLogger : ILogger
{
    public void Log(string message)
    {
        //  Registrar en archivo
    }
}

Friend Interface ILogger
	Sub Log(ByVal message As String)
End Interface
Friend Class ConsoleLogger 'clase de niño
	Implements ILogger

	Public Sub Log(ByVal message As String) Implements ILogger.Log
		Console.WriteLine(message)
	End Sub
End Class
Friend Class FileLogger
	Implements ILogger

	Public Sub Log(ByVal message As String) Implements ILogger.Log
		'  Registrar en archivo
	End Sub
End Class

Clases y métodos abstractos

En C#, una clase abstracta sirve como clase base para otras clases y es incapaz de ser creada por sí misma. La función de una clase abstracta es proporcionar a sus clases derivadas una interfaz y un conjunto de funciones comunes. Actúa como un modelo o plantilla que describe los atributos y métodos que sus clases descendientes deben implementar. Las interfaces son una funcionalidad que ofrece C#. Un tipo de herencia múltiple es posible esencialmente a través de interfaces, que permiten a una clase implementar numerosos contratos.

Se pueden definir uno o más métodos abstractos para una clase base utilizando clases abstractas. Posteriormente, estos métodos abstractos deben tener implementaciones concretas proporcionadas por las clases derivadas.

abstract class Shape
{
    public abstract double Area(); //  Método abstracto
}
class Square : Shape
{
    public double Radius { get; set; }
    public override double Area()
    {
        return Math.PI * Math.Pow(Radius, 2);
    }
}

abstract class Shape
{
    public abstract double Area(); //  Método abstracto
}
class Square : Shape
{
    public double Radius { get; set; }
    public override double Area()
    {
        return Math.PI * Math.Pow(Radius, 2);
    }
}

Friend MustInherit Class Shape
	Public MustOverride Function Area() As Double '  Método abstracto
End Class
Friend Class Square
	Inherits Shape

	Public Property Radius() As Double
	Public Overrides Function Area() As Double
		Return Math.PI * Math.Pow(Radius, 2)
	End Function
End Class

Estas son sólo algunas aplicaciones de la herencia en C#. El grado de flexibilidad previsto en el código base, las conexiones entre clases y los objetivos de diseño influyen en el método elegido.

IronPDF

La biblioteca .NET IronPDF permite a los programadores crear, editar y modificar documentos PDF utilizando el lenguaje C#. La biblioteca IronPDF ofrece una gran variedad de herramientas y funciones que permiten realizar diversas tareas con archivos PDF, como generar PDF a partir de HTML, convertir HTML en PDF, combinar o dividir documentos PDF y añadir texto, imágenes y anotaciones a PDF ya existentes. Para saber más sobre IronPDF, consulte la página documentación página.

Instalar IronPDF

Adquiera la biblioteca IronPDF; el próximo parche lo requiere. Para ello, introduzca el siguiente código en el Gestor de paquetes:

Install-Package IronPDF 
//o 
dotnet add package IronPdf

Otra opción es buscar el paquete "IronPDF" utilizando el gestor de paquetes NuGet. Entre todos los paquetes NuGet relacionados con IronPDF, podemos seleccionar y descargar el paquete requerido de esta lista.

IronPDF en clases heredadas

Para facilitar el trabajo con documentos PDF en C# se ha creado una biblioteca repleta de funciones llamada IronPDF. Al integrar IronPDF con clases heredadas, puede mejorar la funcionalidad de su aplicación y crear, manipular y más PDF con facilidad.

Las ventajas de la herencia con IronPDF

• Organización del código: Al establecer una jerarquía de clases, la herencia ayuda a fomentar una organización organizada del código. Puede crear clases específicas para manejar PDFs con la integración IronPDF y seguir teniendo una base de código limpia y bien organizada.

• Reutilización de código: Las clases que heredan de sus clases base permiten reutilizar código. Esto es especialmente útil si está utilizando una biblioteca como IronPDF, ya que le permite encapsular funciones comunes relacionadas con PDF en una clase base que puede reutilizar en otras áreas de su aplicación.

  Para expandir las capacidades de PdfDocument, particularmente para la integración con IronPDF, vamos a construir una clase llamada IronPdfDocument:

using IronPdf;
public class IronPdfDocument : PdfDocument
{
    //  Aquí se pueden añadir propiedades o métodos adicionales específicos de IronPDF
    public void ConvertToPdf()
    {
        //  Código para convertir el HTML a PDF utilizando IronPDF
           var Renderer = new IronPdf.HtmlToPdf();
           var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
           PDF.SaveAs("Output.pdf");
    }
}

using IronPdf;
public class IronPdfDocument : PdfDocument
{
    //  Aquí se pueden añadir propiedades o métodos adicionales específicos de IronPDF
    public void ConvertToPdf()
    {
        //  Código para convertir el HTML a PDF utilizando IronPDF
           var Renderer = new IronPdf.HtmlToPdf();
           var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
           PDF.SaveAs("Output.pdf");
    }
}

Imports IronPdf
Public Class IronPdfDocument
	Inherits PdfDocument

	'  Aquí se pueden añadir propiedades o métodos adicionales específicos de IronPDF
	Public Sub ConvertToPdf()
		'  Código para convertir el HTML a PDF utilizando IronPDF
		   Dim Renderer = New IronPdf.HtmlToPdf()
		   Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>")
		   PDF.SaveAs("Output.pdf")
	End Sub
End Class

IronPdfDocument es un ejemplo mejorado que deriva de PdfDocument. Esta clase está diseñada para funcionar fácilmente con IronPDF; puede utilizar ciertos atributos o métodos para manejar con facilidad las funciones relacionadas con PDF. Para más información sobre IronPDF aquí.

Creación de un generador de informes PDF

Pongamos en práctica estas ideas utilizando la herencia y IronPDF para crear un generador de informes PDF básico. En primer lugar, trabajaremos con la clase base Report:

public class Report
{
    public virtual void GenerateReport()
    {
                var Renderer = new IronPdf.HtmlToPdf();
                var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
                PDF.SaveAs("Output.pdf");
    }
}

public class Report
{
    public virtual void GenerateReport()
    {
                var Renderer = new IronPdf.HtmlToPdf();
                var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
                PDF.SaveAs("Output.pdf");
    }
}

Public Class Report
	Public Overridable Sub GenerateReport()
				Dim Renderer = New IronPdf.HtmlToPdf()
				Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>")
				PDF.SaveAs("Output.pdf")
	End Sub
End Class

Construyamos ahora PdfReport, una clase derivada que añade características IronPDF y hereda de la clase base:

public class PdfReport : Report
{
    public override void GenerateReport()
    {
        var Renderer = new IronPdf.HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>");
        PDF.SaveAs("Output.pdf");
        Console.WriteLine("Generating PDF report...");
        //  Código adicional específico para la generación de PDF mediante IronPDF
    }
}

public class PdfReport : Report
{
    public override void GenerateReport()
    {
        var Renderer = new IronPdf.HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>");
        PDF.SaveAs("Output.pdf");
        Console.WriteLine("Generating PDF report...");
        //  Código adicional específico para la generación de PDF mediante IronPDF
    }
}

Public Class PdfReport
	Inherits Report

	Public Overrides Sub GenerateReport()
		Dim Renderer = New IronPdf.HtmlToPdf()
		Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>")
		PDF.SaveAs("Output.pdf")
		Console.WriteLine("Generating PDF report...")
		'  Código adicional específico para la generación de PDF mediante IronPDF
	End Sub
End Class

El ejemplo anterior muestra que la propiedad Title y la función GenerateReport son heredadas por PdfReport de la clase existente que es la clase base Report en este ejemplo. Añade una nueva propiedad llamada Author y anula la función GenerateReport con lógica personalizada para la generación de informes PDF basados en IronPDF. A continuación se muestra el PDF de salida generado a partir del código.

Para conocer el código de conversión de cadenas HTML a PDF, consulte aquí.

Conclusión

Cuando se combina con bibliotecas como IronPDF, la herencia es una potente característica que mejora el proceso de desarrollo de aplicaciones. Los fundamentos de la herencia se han cubierto en este post, junto con un útil how-to para integrar la idea con IronPDF.

El desarrollo de estructuras de clases jerárquicas da lugar a una base de código modular y bien estructurada. Cuando se desarrollan clases que heredan las amplias capacidades de sus clases base, pero que se adaptan a tareas específicas, las ventajas de la extensión del código y la reutilización resultan evidentes. Estas ventajas aumentan cuando se integra IronPDF, que ofrece una solución fluida para gestionar documentos PDF en sus aplicaciones C#.

El paquete liviano $749 de IronPDF incorpora un permiso super duradero, opciones de rediseño y un período extendido de soporte de programación. Durante el tiempo de prueba con marca de agua, los clientes pueden evaluar el artículo en condiciones de aplicación auténticas. Para obtener más información sobre el valor, los permisos y el formulario preliminar de IronPDF, visite la página página de licencia. Visite la página oficial sitio web para familiarizarse con otros productos de Iron Software.