Encapsulamiento en C#: ¡Protege tu Código y Domina la POO!

Antes de tocar una línea de código, entendamos bien el concepto.

¿Qué es el Encapsulamiento?

El encapsulamiento es uno de los cuatro pilares de la Programación Orientada a Objetos, su principio es simple:

Agrupar los atributos y los métodos que operan sobre esos datos dentro de una misma clase, y ocultar los detalles de la implementación interna al mundo exterior.

En lugar de exponer los detalles, proporcionamos una interfaz pública y controlada.

¿Y para qué sirve el encapsulamiento? ¿Y Por qué ocultar cosas?

Propósito:

• Integridad de los Datos: Es la razón principal. Evita que alguien, por accidente o intencionadamente, ponga datos inválidos en nuestros objetos. No querrías que el kilometraje de tu coche fuera un número negativo, ¿verdad?
• Seguridad: Previene el acceso o la modificación no autorizada de partes críticas del objeto.
• Facilidad de Mantenimiento: Si quieres cambiar cómo funciona algo internamente (mejorar el 'motor'), puedes hacerlo con total libertad siempre que la interfaz pública (el 'volante') siga funcionando igual. Los cambios no rompen el resto del programa.

En resumen, el encapsulamiento nos da control. Y en programación, el control es poder. Ahora, veamos cómo se implementa esto en C#.

Modificadores de Acceso - Poniendo el Candado

La herramienta principal para encapsular son los modificadores de acceso, son palabras clave que definen quién puede ver o usar un miembro de una clase.

¿Qué son los modificadores private y public?

• public: Totalmente accesible, se puede ver y modificar desde cualquier parte del código.
• private: Máxima restricción, solo es accesible desde dentro de la misma clase, el mundo exterior ni siquiera sabe que existe.

TÚ: "(También existe protected, que veremos en el vídeo de Herencia, ¡así que suscríbete!). Por convención, los atributos o datos de una clase casi siempre deberían ser privados. Vamos a modificar nuestra clase Carro para proteger su estado interno."

// Carro.cs
// Creamos nuestro namespace para organizar nuestro código.
namespace console_poo_ewebik;

// Esta es nuestra PLANTILLA o nuestro PLANO.
public class Carro
{
    // Atributos PROTEGIDOS.
    private string modelo;
    private double kilometraje;
    private double combustibleLitros;
    private double capacidadTanque;

    // Este es el constructor de la clase,
    // se ejecuta al crear un objeto de tipo Carro.
    // El constructor es un método especial
    // que se llama automáticamente al crear una instancia de la clase.
    public Carro(string modeloInicial, double capacidadTanque)
    {
        this.modelo = modeloInicial;
        this.capacidadTanque = capacidadTanque;
        //Iniciamos con el tanque lleno.
        this.combustibleLitros = capacidadTanque;
        this.kilometraje = 0;
    }

    // Este método es público, es parte de la interfaz.
    public void MostrarDetalles()
    {
        // Desde DENTRO de la clase, sí podemos acceder a los atributos privados.
        Console.WriteLine(
            $"Modelo: {this.modelo}"
            + $", Kilometraje: {this.kilometraje}"
            + $", Capacidad Tanque: {this.capacidadTanque} L"
            + $", Combustible: {this.combustibleLitros} L");
    }
}

Con nuestra clase lista podemos crear todos los objetos que necesitemos, pero no podemos editar o leer los atributos privados, si lo intentamos, nos lanzará un error que indica el atributo  "es inaccesible debido a su nivel de protección".

///Program.cs
using console_poo_ewebik;

// Objeto de tipo Carro.
Carro miTesla = new Carro("Tesla Model S", 75);
miTesla.MostrarDetalles();

// ¡ESTO AHORA GENERA UN ERROR DE COMPILACIÓN!
// ERROR: 'Carro.Kilometraje' is inaccessible due to its protection level.
//miTesla.kilometraje = -500;
//Console.WriteLine(miTesla.kilometraje);

¡Perfecto! Hemos puesto un candado, nadie puede ahora modificar el kilometraje o el combustible directamente, hemos prevenido un bug catastrófico. Pero... ¿Cómo podemos leer o modificar esos valores de forma segura? Si no podemos acceder a ellos ¿De qué sirven?

Getters y Setters - La Puerta Controlada

Aquí es donde entra la magia del encapsulamiento: creamos métodos públicos especiales para controlar el acceso a nuestros datos privados.

¿Qué son los Getters y Setters en programación orientada a objetos?

• Getter (Obtenedor): Es un método público que lee y devuelve el valor de un atributo privado, su única función es obtener el dato.
• Setter (Establecedor): es un método público que modifica el valor de un atributo privado., aquí es donde ponemos nuestra lógica de validación.

En C#, en lugar de crear métodos como getKilometraje() y setKilometraje(), usamos una sintaxis mucho más elegante y poderosa llamada Propiedades.

// Carro.cs
// Creamos nuestro namespace para organizar nuestro código.
namespace console_poo_ewebik;

// Esta es nuestra PLANTILLA o nuestro PLANO.
public class Carro
{
    // Atributos PROTEGIDOS.
    private string modelo;
    private double kilometraje;
    private double combustibleLitros;
    private double capacidadTanque;

    // Propiedad pública para el atributo privado 'modelo'
    // Solo tiene un 'get', por lo que es de SOLO LECTURA desde el exterior.
    public string Modelo
    {
        get { return this.modelo; }
    }

    // Propiedad pública para el atributo privado 'kilometraje'
    // También es de solo lectura. Solo nuestros métodos internos lo pueden cambiar.
    public double Kilometraje
    {
        get { return this.kilometraje; }
    }

    // Propiedad pública para 'combustibleLitros'
    // ¡Aquí está la magia! Tiene un get y un set con VALIDACIÓN.
    public double CombustibleLitros
    {
        get { return this.combustibleLitros; }
        set
        {
            // 'value' es una palabra reservada que representa el valor que se intenta asignar.
            if (value < 0)
            {
                Console.WriteLine("Error: El combustible no puede ser negativo.");
            }
            else if (value > this.capacidadTanque)
            {
                this.combustibleLitros = this.capacidadTanque; // Llenamos el tanque al máximo.
                Console.WriteLine("Tanque lleno. El exceso de combustible se ha derramado.");
            }
            else
            {
                this.combustibleLitros = value; // Asignación válida
            }
        }
    }


    // Este es el constructor de la clase,
    // se ejecuta al crear un objeto de tipo Carro.
    // El constructor es un método especial
    // que se llama automáticamente al crear una instancia de la clase.
    public Carro(string modeloInicial, double capacidadTanque)
    {
        this.modelo = modeloInicial;
        this.capacidadTanque = capacidadTanque;
        //Iniciamos con el tanque lleno.
        this.combustibleLitros = capacidadTanque;
        this.kilometraje = 0;
    }

    // Este método es público, es parte de la interfaz.
    public void MostrarDetalles()
    {
        // Desde DENTRO de la clase, sí podemos acceder a los atributos privados.
        Console.WriteLine(
            $"Modelo: {this.modelo}"
            + $", Kilometraje: {this.kilometraje}"
            + $", Capacidad Tanque: {this.capacidadTanque} L"
            + $", Combustible: {this.combustibleLitros} L");
    }
}

¡Miren qué limpio! Ahora, cuando alguien intente interactuar con el combustible, está obligado a pasar por nuestra puerta de seguridad. Veamos qué pasa.

//Program.cs
using console_poo_ewebik;

// Objeto de tipo Carro.
Carro miTesla = new Carro("Tesla Model S", 75);

// Leemos el valor usando el 'get' de la propiedad.
Console.WriteLine(
    $"Combustible inicial: {miTesla.CombustibleLitros} L");
//Que impreme: Combustible inicial: 75 L

// Intentamos poner un valor inválido usando el 'set'
miTesla.CombustibleLitros = -20;
// Que Imprime: "Error: El combustible no puede ser negativo."
Console.WriteLine(
    $"Combustible inicial: {miTesla.CombustibleLitros} L");
//Sigue siendo 75 L

// Intentamos sobrellenar el tanque
miTesla.CombustibleLitros = 100;
// Imprime: Tanque lleno. El exceso de combustible se ha derramado.
Console.WriteLine(
    $"Combustible inicial: {miTesla.CombustibleLitros} L");
//Se ajusta a 75 L

// Ahora, intentamos llenar el tanque con un valor válido
miTesla.CombustibleLitros = 50;
Console.WriteLine(
    $"Combustible inicial: {miTesla.CombustibleLitros} L");
// Imprime: Combustible inicial: 50 L

¿Ves el poder de esto? Nuestro objeto ahora se protege a sí mismo, hemos garantizado la integridad de los datos.