C# Programación orientada a objetos

La programación orientada a objetos (OOP) representa uno de los paradigmas más importantes en el desarrollo de software moderno. C# se ha consolidado como un lenguaje versátil y potente que implementa este paradigma de forma elegante y completa, convirtiéndose en una herramienta fundamental para desarrolladores profesionales en el ecosistema Microsoft y más allá.

¿Qué es la programación orientada a objetos?

La OOP es un paradigma de programación que utiliza "objetos" como elementos fundamentales. Estos objetos son instancias de clases, que funcionan como plantillas o moldes que definen las características (propiedades) y comportamientos (métodos) que tendrán los objetos creados a partir de ellas.

Este enfoque permite modelar problemas del mundo real de manera más intuitiva, organizando el código en unidades cohesivas que encapsulan datos y funcionalidad relacionada, facilitando así el desarrollo, mantenimiento y escalabilidad de aplicaciones complejas.

C# como lenguaje orientado a objetos

C# fue diseñado desde sus inicios como un lenguaje orientado a objetos puro, incorporando todos los conceptos fundamentales de este paradigma:

• Encapsulación: Permite ocultar los detalles internos de implementación y exponer solo lo necesario.
• Herencia: Facilita la reutilización de código mediante la creación de jerarquías de clases.
• Polimorfismo: Permite que objetos de diferentes clases respondan de manera distinta al mismo mensaje.
• Abstracción: Posibilita representar conceptos complejos de forma simplificada.

A lo largo de este curso, exploraremos estos conceptos y muchos más, desde los fundamentos hasta técnicas avanzadas que te permitirán aprovechar todo el potencial de C# como lenguaje OOP.

Fundamentos de clases y objetos en C#

En C#, todo comienza con las clases y objetos. Una clase es una estructura que define un tipo de datos, mientras que un objeto es una instancia concreta de esa clase. Por ejemplo:

// Definición de una clase
public class Persona
{
    // Propiedades
    public string Nombre { get; set; }
    public int Edad { get; set; }
    
    // Método
    public void Presentarse()
    {
        Console.WriteLine($"Hola, soy {Nombre} y tengo {Edad} años.");
    }
}

// Creación de un objeto (instancia de la clase)
Persona persona1 = new Persona();
persona1.Nombre = "Ana";
persona1.Edad = 30;
persona1.Presentarse(); // Salida: Hola, soy Ana y tengo 30 años.

Este ejemplo ilustra cómo una clase encapsula tanto datos (propiedades Nombre y Edad) como comportamiento (método Presentarse).

Encapsulación y control de acceso

La encapsulación es un principio fundamental que permite controlar el acceso a los miembros de una clase. C# proporciona modificadores de acceso como public, private, protected e internal para este fin:

public class CuentaBancaria
{
    // Campo privado - solo accesible dentro de la clase
    private decimal _saldo;
    
    // Propiedad pública con lógica de validación
    public decimal Saldo
    {
        get { return _saldo; }
        private set { _saldo = value; } // Solo se puede modificar dentro de la clase
    }
    
    public void Depositar(decimal cantidad)
    {
        if (cantidad <= 0)
            throw new ArgumentException("La cantidad debe ser positiva");
            
        _saldo += cantidad;
    }
}

Este patrón de diseño protege los datos internos y garantiza que solo puedan modificarse a través de métodos controlados, manteniendo la integridad de los datos.

Constructores y ciclo de vida de los objetos

Los constructores son métodos especiales que se ejecutan cuando se crea un objeto, permitiendo inicializar sus propiedades. C# también proporciona destructores (o finalizadores) que se ejecutan cuando un objeto es eliminado por el recolector de basura:

public class Recurso
{
    private string _nombre;
    
    // Constructor sin parámetros
    public Recurso()
    {
        _nombre = "Sin nombre";
        Console.WriteLine("Recurso creado");
    }
    
    // Constructor con parámetros
    public Recurso(string nombre)
    {
        _nombre = nombre;
        Console.WriteLine($"Recurso '{_nombre}' creado");
    }
    
    // Destructor
    ~Recurso()
    {
        Console.WriteLine($"Recurso '{_nombre}' liberado");
    }
}

C# también proporciona el patrón IDisposable para una gestión más controlada de recursos:

public class ConexionBD : IDisposable
{
    private bool _disposed = false;
    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Liberar recursos administrados
            }
            
            // Liberar recursos no administrados
            _disposed = true;
        }
    }
}