La 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 lenguaje de programación moderno orientado a objetos, ofrece un marco robusto para construir aplicaciones complejas. Esta guía introduce los conceptos de OOP 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 manera efectiva. También discutiremos cómo se podrían aplicar estos principios con la librería IronPDF para C#.
En el corazón de OOP se encuentran varios conceptos clave: clases, objetos, herencia, polimorfismo, abstracción y encapsulamiento. Estos conceptos permiten a los desarrolladores modelar entidades del mundo real, manejar la complejidad y mejorar la mantenibilidad de su código.
Una clase crea objetos individuales. La clase es un plano que define los datos y comportamientos que todos los objetos de la clase comparten. Un objeto es una manifestación de una clase. Encarna valores reales en lugar de marcadores abstractos definidos en el plano de la clase.
public class Car // A class declared as 'Car' defines its structure and behavior.
{
public string Name;
public string Color;
public void DisplayInfo()
{
Console.WriteLine($"Name: {Name}, Color: {Color}");
}
}
class Program // This is the program class, serving as the entry point of a C# program.
{
static void Main(string[] args)
{
Car myCar = new Car();
myCar.Name = "Toyota";
myCar.Color = "Red";
myCar.DisplayInfo();
}
}Public Class Car ' A class declared as 'Car' defines its structure and behavior.
Public Name As String
Public Color As String
Public Sub DisplayInfo()
Console.WriteLine($"Name: {Name}, Color: {Color}")
End Sub
End Class
Friend Class Program ' This is the program class, serving as the entry point of a C# program.
Shared Sub Main(ByVal args() As String)
Dim myCar As New Car()
myCar.Name = "Toyota"
myCar.Color = "Red"
myCar.DisplayInfo()
End Sub
End ClassEn este ejemplo, la clase Car tiene dos miembros de datos (Name 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.
La herencia permite que una clase herede las propiedades y métodos de una clase existente. La clase cuyas propiedades se heredan se llama la clase base, y la clase que hereda esas propiedades se llama clase derivada.
public class Vehicle
{
public string LicensePlate;
public void Honk()
{
Console.WriteLine("Honking");
}
}
public class Truck : Vehicle // Truck is a child class derived from the Vehicle base class.
{
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 ' Truck is a child class derived from the Vehicle base class.
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 ClassEn este ejemplo, Truck es una clase derivada que extiende la clase base Vehicle, heredando su campo LicensePlate y el método Honk mientras añade un nuevo campo, CargoCapacity.
El polimorfismo permite que los objetos se manejen como instancias de su clase base en lugar de su clase específica. La abstracción te permite definir clases abstractas e interfaces que no pueden ser instanciadas pero que pueden ser utilizadas como clases base.
Las clases abstractas no pueden ser instanciadas y por lo general se utilizan para proporcionar una definición común de una clase base que múltiples clases derivadas puedan compartir.
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 ClassUna 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 // Defining a new class CustomShape that implements IDrawable and 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 ' Defining a new class CustomShape that implements IDrawable and 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 ClassEl encapsulamiento es el mecanismo de restringir el acceso a ciertos componentes de un objeto y de prevenir que terceras partes vean la representación interna. Esto se logra a través del uso de modificadores de acceso.
public class Person
{
private string name; // Private variable, inaccessible outside the class
public string Name // Public property to access the private variable
{
get { return name; }
set { name = value; }
}
}
// Example showing a simple customer class with encapsulated data
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 ' Private variable, inaccessible outside the class
Public Property Name() As String ' Public property to access the private variable
Get
Return name_Conflict
End Get
Set(ByVal value As String)
name_Conflict = value
End Set
End Property
End Class
' Example showing a simple customer class with encapsulated data
Public Class Customer
Public Property Name() As String
Public Property Address() As String
End ClassEn este ejemplo, el campo name es privado, haciéndolo inaccesible fuera de la clase Person. El acceso a este campo se proporciona a través de la propiedad pública Name, que incluye métodos get y set.
Ahora, exploraremos un ejemplo que involucra múltiples 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.");
}
}
}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 NamespaceEn este ejemplo, Drive() es un método abstracto de la clase abstracta Vehicle. Car es una clase derivada que implementa Drive(), y ElectricCar es otro nivel hacia abajo en la jerarquía, añadiendo nuevas características como BatteryLevel y su propia implementación de Drive(). Esta estructura demuestra la abstracción, el encapsulamiento, la herencia y el polimorfismo trabajando juntos en una aplicación de C#.
La librería IronPDF for .NET es una herramienta versátil para desarrolladores de C#, diseñada para simplificar el proceso de crear, editar y extraer documentos PDF dentro de aplicaciones .NET. IronPDF tiene la capacidad de generar fácilmente PDFs a partir de cadenas HTML, URLs o archivos ASPX, ofreciendo un alto nivel de control sobre el proceso de creación y manipulación de PDFs. Además, IronPDF admite características avanzadas como agregar cabeceras y pies de página, marcas de agua y encriptación, convirtiéndolo en una solución integral para manejar PDFs en aplicaciones .NET.
Aquí hay un ejemplo simplificado que demuestra el uso de IronPDF dentro de una aplicación de C#, incorporando la palabra clave virtual para ilustrar cómo se podría extender la funcionalidad de IronPDF a través de la herencia, un concepto clave en OOP. Supongamos que tenemos una clase base que genera un informe básico en PDF 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)
{
// Create text header
TextHeaderFooter textHeader = new TextHeaderFooter
{
CenterText = headerContent,
};
document.AddTextHeaders(textHeader);
}
}
class Program
{
static void Main(string[] args)
{
License.LicenseKey = "License-Key";
// HTML content for the report
string htmlContent = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>";
// Using BasicReportGenerator
BasicReportGenerator basicReportGenerator = new BasicReportGenerator();
var basicPdf = basicReportGenerator.GenerateReport(htmlContent);
basicPdf.SaveAs("basic_report.pdf");
// Using 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)
' Create text header
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"
' HTML content for the report
Dim htmlContent As String = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>"
' Using BasicReportGenerator
Dim basicReportGenerator As New BasicReportGenerator()
Dim basicPdf = basicReportGenerator.GenerateReport(htmlContent)
basicPdf.SaveAs("basic_report.pdf")
' Using 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 ClassEn 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, sobrescribe el método GenerateReport para agregar un encabezado personalizado al PDF después de que ha sido generado por el método base. Aquí está el informe personalizado generado por el código:
Al comprender y aplicar los principios básicos de OOP, los principiantes pueden dar pasos significativos hacia el dominio de C# y el desarrollo de soluciones de software robustas. La herencia y el polimorfismo permiten la reutilización y flexibilidad del código, permitiendo a las nuevas clases construir sobre estructuras y funcionalidades existentes. La abstracción y el encapsulamiento aseguran que las clases solo expongan lo necesario al mundo exterior, manteniendo el funcionamiento interno privado y seguro de usos no intencionados. Puede probar la prueba gratuita para generación de PDF en C# de IronPDF, que está disponible a partir de liteLicense.
Jacob Mellor is Chief Technology Officer at Iron Software and a visionary engineer pioneering C# PDF technology. As the original developer behind Iron Software's core codebase, he has shaped the company's product architecture since its inception, transforming it alongside CEO Cameron Rimington into a 50+ person company serving NASA, Tesla, and global government agencies.
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
