C# Orientado a Objetos (Cómo funciona para desarrolladores)

Programación orientada a objetos (OOP) es un concepto fundamental en el desarrollo de software, que permite a los programadores crear código modular, reutilizable y adaptable. C#, un moderno lenguaje de programación orientado a objetos, ofrece un marco sólido para crear aplicaciones complejas. Esta guía introduce los conceptos de programación orientada a objetos utilizando C#, centrándose en implementaciones prácticas y ejemplos de codificación para ayudar a los principiantes a comprender y aplicar estos principios de forma eficaz. También hablaremos de cómo aplicar estos principios con Biblioteca IronPDF.

Comprender los conceptos de la programación orientada a objetos

En el corazón de la programación orientada a objetos se encuentran varios conceptos clave: clases, objetos, herencia, polimorfismo, abstracción y encapsulación. Estos conceptos permiten a los desarrolladores modelar entidades del mundo real, gestionar la complejidad y mejorar la mantenibilidad de su código.

Clases y objetos: Los bloques de construcción

Una clase crea objetos individuales. La clase es un plano que define los datos y el comportamiento que comparten todos los objetos de la clase. Un objeto es una manifestación de clase. Incorpora valores reales en lugar de marcadores de posición abstractos definidos en el plano de la clase.

public class Car //  Una clase declarada como 'Coche' define su estructura y comportamiento.
{
    public string Name;
    public string Color;
    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {Name}, Color: {Color}");
    }
}
class Program //  Esta es la clase de programa, que sirve como punto de entrada del programa C#
{
    static void Main(string [] args)
    {
        Car myCar = new Car();
        myCar.Name = "Toyota";
        myCar.Color = "Red";
        myCar.DisplayInfo();
    }
}

public class Car //  Una clase declarada como 'Coche' define su estructura y comportamiento.
{
    public string Name;
    public string Color;
    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {Name}, Color: {Color}");
    }
}
class Program //  Esta es la clase de programa, que sirve como punto de entrada del programa C#
{
    static void Main(string [] args)
    {
        Car myCar = new Car();
        myCar.Name = "Toyota";
        myCar.Color = "Red";
        myCar.DisplayInfo();
    }
}

Public Class Car '  Una clase declarada como 'Coche' define su estructura y comportamiento.
	Public Name As String
	Public Color As String
	Public Sub DisplayInfo()
		Console.WriteLine($"Name: {Name}, Color: {Color}")
	End Sub
End Class
Friend Class Program '  Esta es la clase de programa, que sirve como punto de entrada del programa C#
	Shared Sub Main(ByVal args() As String)
		Dim myCar As New Car()
		myCar.Name = "Toyota"
		myCar.Color = "Red"
		myCar.DisplayInfo()
	End Sub
End Class

En este ejemplo, la clase Car tiene dos miembros de datos (Nombre y Color) y un método (DisplayInfo). El método Main, que sirve como punto de entrada de la aplicación, crea una instancia de la clase Car y asigna valores a sus campos antes de llamar a su método para mostrar estos valores.

Herencia: Extensión de clases existentes

La herencia permite a una clase heredar las propiedades y métodos de una clase existente. La clase cuyas propiedades se heredan se denomina clase base, y la clase que hereda esas propiedades se denomina clase derivada.

public class Vehicle
{
    public string LicensePlate;
    public void Honk()
    {
        Console.WriteLine("Honking");
    }
}
public class Truck : Vehicle //  Camión es una clase hija derivada de la clase base Vehículo
{
    public int CargoCapacity;
}
class Program
{
    static void Main(string [] args)
    {
        Truck myTruck = new Truck();
        myTruck.LicensePlate = "ABC123";
        myTruck.CargoCapacity = 5000;
        myTruck.Honk();
    }
}

public class Vehicle
{
    public string LicensePlate;
    public void Honk()
    {
        Console.WriteLine("Honking");
    }
}
public class Truck : Vehicle //  Camión es una clase hija derivada de la clase base Vehículo
{
    public int CargoCapacity;
}
class Program
{
    static void Main(string [] args)
    {
        Truck myTruck = new Truck();
        myTruck.LicensePlate = "ABC123";
        myTruck.CargoCapacity = 5000;
        myTruck.Honk();
    }
}

Public Class Vehicle
	Public LicensePlate As String
	Public Sub Honk()
		Console.WriteLine("Honking")
	End Sub
End Class
Public Class Truck '  Camión es una clase hija derivada de la clase base Vehículo
	Inherits Vehicle

	Public CargoCapacity As Integer
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim myTruck As New Truck()
		myTruck.LicensePlate = "ABC123"
		myTruck.CargoCapacity = 5000
		myTruck.Honk()
	End Sub
End Class

En este ejemplo, Truck es una clase derivada que extiende la clase base Vehicle, heredando su campo LicensePlate y su método Honk, a la vez que añade un nuevo campo, CargoCapacity.

Polimorfismo y abstracción: Interfaces y clases abstractas

El polimorfismo permite manejar los objetos como instancias de su clase base en lugar de su clase específica. La abstracción permite definir clases abstractas e interfaces que no pueden instanciarse, pero que pueden utilizarse como clases base.

Clases y métodos abstractos

Las clases abstractas no pueden instanciarse y suelen utilizarse para proporcionar una definición común de una clase base que pueden compartir varias clases derivadas.

public abstract class Shape
{
    public abstract void Draw();
}
public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

public abstract class Shape
{
    public abstract void Draw();
}
public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

Public MustInherit Class Shape
	Public MustOverride Sub Draw()
End Class
Public Class Circle
	Inherits Shape

	Public Overrides Sub Draw()
		Console.WriteLine("Drawing a circle")
	End Sub
End Class

Implementación de múltiples interfaces

Una interfaz establece un acuerdo, o contrato, que las clases pueden cumplir implementando sus métodos definidos. Las clases pueden implementar múltiples interfaces, lo que permite una forma de polimorfismo.

public interface IDrawable
{
    void Draw();
}
public interface IColorable
{
    void Color();
}
public class CustomShape : IDrawable, IColorable //  Definir una nueva clase CustomShape que implemente IDrawable y IColorable
{
    public void Draw()
    {
        Console.WriteLine("Custom shape drawn");
    }
    public void Color()
    {
        Console.WriteLine("Custom shape colored");
    }
}

public interface IDrawable
{
    void Draw();
}
public interface IColorable
{
    void Color();
}
public class CustomShape : IDrawable, IColorable //  Definir una nueva clase CustomShape que implemente IDrawable y IColorable
{
    public void Draw()
    {
        Console.WriteLine("Custom shape drawn");
    }
    public void Color()
    {
        Console.WriteLine("Custom shape colored");
    }
}

Public Interface IDrawable
	Sub Draw()
End Interface
Public Interface IColorable
	Sub Color()
End Interface
Public Class CustomShape '  Definir una nueva clase CustomShape que implemente IDrawable y IColorable
	Implements IDrawable, IColorable

	Public Sub Draw() Implements IDrawable.Draw
		Console.WriteLine("Custom shape drawn")
	End Sub
	Public Sub Color() Implements IColorable.Color
		Console.WriteLine("Custom shape colored")
	End Sub
End Class

Encapsulación: Protección de datos

La encapsulación es el mecanismo que permite restringir el acceso a determinados componentes de un objeto e impedir que personas externas vean la representación interna. Esto se consigue mediante el uso de modificadores de acceso.

public class Person
{
    private string name; //  Variable privada, inaccesible fuera de la clase
    public string Name   //  Propiedad pública para acceder a la variable privada
    {
        get { return name; }
        set { name = value; }
    }
}
//  Ejemplo de una clase cliente sencilla con datos encapsulados
public class Customer
{
    public string Name { get; set; }
    public string Address { get; set; } 
}

public class Person
{
    private string name; //  Variable privada, inaccesible fuera de la clase
    public string Name   //  Propiedad pública para acceder a la variable privada
    {
        get { return name; }
        set { name = value; }
    }
}
//  Ejemplo de una clase cliente sencilla con datos encapsulados
public class Customer
{
    public string Name { get; set; }
    public string Address { get; set; } 
}

Public Class Person
'INSTANT VB NOTE: The field name was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private name_Conflict As String '  Variable privada, inaccesible fuera de la clase
	Public Property Name() As String '  Propiedad pública para acceder a la variable privada
		Get
			Return name_Conflict
		End Get
		Set(ByVal value As String)
			name_Conflict = value
		End Set
	End Property
End Class
'  Ejemplo de una clase cliente sencilla con datos encapsulados
Public Class Customer
	Public Property Name() As String
	Public Property Address() As String
End Class

En este ejemplo, el campo nombre es privado, por lo que es inaccesible fuera de la clase Persona. El acceso a este campo se realiza a través de la propiedad pública Nombre, que incluye los métodos get y set.

Casos prácticos y ejemplos de codificación

A continuación, exploraremos un ejemplo en el que intervienen varias clases para demostrar estos principios en acción.

using System;
namespace OOPExample
{
    public class Program
    {
        static void Main(string [] args)
        {
            ElectricCar myElectricCar = new ElectricCar();
            myElectricCar.Make = "Tesla";
            myElectricCar.Model = "Model 3";
            myElectricCar.BatteryLevel = 100;
            myElectricCar.Drive();
            myElectricCar.Charge();
        }
    }
    public abstract class Vehicle
    {
        public string Make { get; set; }
        public string Model { get; set; }
        public abstract void Drive();
    }
    public class Car : Vehicle
    {
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving.");
        }
    }
    public class ElectricCar : Car
    {
        public int BatteryLevel { get; set; }
        public void Charge()
        {
            Console.WriteLine("Charging the car.");
        }
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving silently.");
        }
    }
}

using System;
namespace OOPExample
{
    public class Program
    {
        static void Main(string [] args)
        {
            ElectricCar myElectricCar = new ElectricCar();
            myElectricCar.Make = "Tesla";
            myElectricCar.Model = "Model 3";
            myElectricCar.BatteryLevel = 100;
            myElectricCar.Drive();
            myElectricCar.Charge();
        }
    }
    public abstract class Vehicle
    {
        public string Make { get; set; }
        public string Model { get; set; }
        public abstract void Drive();
    }
    public class Car : Vehicle
    {
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving.");
        }
    }
    public class ElectricCar : Car
    {
        public int BatteryLevel { get; set; }
        public void Charge()
        {
            Console.WriteLine("Charging the car.");
        }
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving silently.");
        }
    }
}

Imports System
Namespace OOPExample
	Public Class Program
		Shared Sub Main(ByVal args() As String)
			Dim myElectricCar As New ElectricCar()
			myElectricCar.Make = "Tesla"
			myElectricCar.Model = "Model 3"
			myElectricCar.BatteryLevel = 100
			myElectricCar.Drive()
			myElectricCar.Charge()
		End Sub
	End Class
	Public MustInherit Class Vehicle
		Public Property Make() As String
		Public Property Model() As String
		Public MustOverride Sub Drive()
	End Class
	Public Class Car
		Inherits Vehicle

		Public Overrides Sub Drive()
			Console.WriteLine($"The {Make} {Model} is driving.")
		End Sub
	End Class
	Public Class ElectricCar
		Inherits Car

		Public Property BatteryLevel() As Integer
		Public Sub Charge()
			Console.WriteLine("Charging the car.")
		End Sub
		Public Overrides Sub Drive()
			Console.WriteLine($"The {Make} {Model} is driving silently.")
		End Sub
	End Class
End Namespace

En este ejemplo, Drive() es un método abstracto de la clase abstracta Vehículo. Car es una clase derivada que implementa Drive(), y ElectricCar es otro nivel en la jerarquía, añadiendo nuevas características como BatteryLevel y su propio Drive() implementación. Esta estructura demuestra la abstracción, encapsulación, herencia y polimorfismo trabajando juntos en una aplicación C#.

IronPDF: C# Biblioteca PDF

IronPDF es una biblioteca versátil para desarrolladores C#, diseñada para simplificar el proceso de creación, edición y extracción de documentos PDF dentro de aplicaciones .NET. IronPDF tiene la capacidad de generar PDF a partir de cadenas HTML, URL o archivos ASPX, ofreciendo un alto nivel de control sobre el proceso de creación y manipulación de PDF. Además, IronPDF admite funciones avanzadas como la adición de encabezados y pies de página, marcas de agua y cifrado, lo que lo convierte en una solución completa para manejar PDF en aplicaciones .NET.

Ejemplo de IronPDF con OOP

He aquí un ejemplo simplificado que demuestra el uso de IronPDF dentro de una aplicación C#, incorporando la palabra clave virtual para ilustrar cómo se puede extender la funcionalidad de IronPDF a través de la herencia, un concepto básico en la programación orientada a objetos. Supongamos que tenemos una clase base que genera un informe PDF básico y una clase derivada que extiende esta funcionalidad para incluir un encabezado personalizado:

using IronPdf;
public class BasicReportGenerator
{
    public virtual PdfDocument GenerateReport(string htmlContent)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        return pdf;
    }
}
public class CustomReportGenerator : BasicReportGenerator
{
    public override PdfDocument GenerateReport(string htmlContent)
    {
        var pdf = base.GenerateReport(htmlContent);
        AddCustomHeader(pdf, "Custom Report Header");
        return pdf;
    }
    private void AddCustomHeader(PdfDocument document, string headerContent)
    {
        //  Crear cabecera de texto
        TextHeaderFooter textHeader = new TextHeaderFooter
        {
            CenterText = headerContent,
        };
        document.AddTextHeaders(textHeader);
    }
}
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        //  Contenido HTML del informe
        string htmlContent = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>";
        //  Uso de BasicReportGenerator
        BasicReportGenerator basicReportGenerator = new BasicReportGenerator();
        var basicPdf = basicReportGenerator.GenerateReport(htmlContent);
        basicPdf.SaveAs("basic_report.pdf");
        //  Uso de CustomReportGenerator
        CustomReportGenerator customReportGenerator = new CustomReportGenerator();
        var customPdf = customReportGenerator.GenerateReport(htmlContent);
        customPdf.SaveAs("custom_report.pdf");
        Console.WriteLine("PDF reports generated successfully.");
    }
}

using IronPdf;
public class BasicReportGenerator
{
    public virtual PdfDocument GenerateReport(string htmlContent)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        return pdf;
    }
}
public class CustomReportGenerator : BasicReportGenerator
{
    public override PdfDocument GenerateReport(string htmlContent)
    {
        var pdf = base.GenerateReport(htmlContent);
        AddCustomHeader(pdf, "Custom Report Header");
        return pdf;
    }
    private void AddCustomHeader(PdfDocument document, string headerContent)
    {
        //  Crear cabecera de texto
        TextHeaderFooter textHeader = new TextHeaderFooter
        {
            CenterText = headerContent,
        };
        document.AddTextHeaders(textHeader);
    }
}
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        //  Contenido HTML del informe
        string htmlContent = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>";
        //  Uso de BasicReportGenerator
        BasicReportGenerator basicReportGenerator = new BasicReportGenerator();
        var basicPdf = basicReportGenerator.GenerateReport(htmlContent);
        basicPdf.SaveAs("basic_report.pdf");
        //  Uso de CustomReportGenerator
        CustomReportGenerator customReportGenerator = new CustomReportGenerator();
        var customPdf = customReportGenerator.GenerateReport(htmlContent);
        customPdf.SaveAs("custom_report.pdf");
        Console.WriteLine("PDF reports generated successfully.");
    }
}

Imports IronPdf
Public Class BasicReportGenerator
	Public Overridable Function GenerateReport(ByVal htmlContent As String) As PdfDocument
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		Return pdf
	End Function
End Class
Public Class CustomReportGenerator
	Inherits BasicReportGenerator

	Public Overrides Function GenerateReport(ByVal htmlContent As String) As PdfDocument
		Dim pdf = MyBase.GenerateReport(htmlContent)
		AddCustomHeader(pdf, "Custom Report Header")
		Return pdf
	End Function
	Private Sub AddCustomHeader(ByVal document As PdfDocument, ByVal headerContent As String)
		'  Crear cabecera de texto
		Dim textHeader As New TextHeaderFooter With {.CenterText = headerContent}
		document.AddTextHeaders(textHeader)
	End Sub
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		'  Contenido HTML del informe
		Dim htmlContent As String = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>"
		'  Uso de BasicReportGenerator
		Dim basicReportGenerator As New BasicReportGenerator()
		Dim basicPdf = basicReportGenerator.GenerateReport(htmlContent)
		basicPdf.SaveAs("basic_report.pdf")
		'  Uso de CustomReportGenerator
		Dim customReportGenerator As New CustomReportGenerator()
		Dim customPdf = customReportGenerator.GenerateReport(htmlContent)
		customPdf.SaveAs("custom_report.pdf")
		Console.WriteLine("PDF reports generated successfully.")
	End Sub
End Class

En este ejemplo, BasicReportGenerator tiene un método GenerateReport que toma contenido HTML y genera un documento PDF usando IronPDF. La clase CustomReportGenerator, que hereda de BasicReportGenerator, anula el método GenerateReport para añadir una cabecera personalizada al PDF después de que lo haya generado el método base. Aquí está el informe personalizado generado por el código:

Conclusión

Al comprender y aplicar los principios básicos de la programación orientada a objetos, los principiantes pueden dar pasos significativos hacia el dominio de C# y el desarrollo de soluciones de software sólidas. La herencia y el polimorfismo permiten la reutilización del código y la flexibilidad, permitiendo que las nuevas clases se basen en estructuras y funcionalidades existentes. La abstracción y la encapsulación garantizan que las clases sólo expongan al mundo exterior lo necesario, manteniendo el funcionamiento interno privado y a salvo de usos no deseados. Puede probar IronPDF prueba gratuita que está disponible a partir de $749.