Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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.
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.
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 // 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 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 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 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 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 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.
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 // 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 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 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.
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.
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
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 // 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
{
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 Class
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; // 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
{
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 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.
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 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.
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)
{
// 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.");
}
}
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 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:
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 gratuitaque está disponible a partir de $749.
9 productos API .NET para sus documentos de oficina