POO en C# y colecciones fuertemente tipadas

Cómo usar esta guía

• Pregunta
• →
• Exploración
• →
• Implementación
• →
• Resultado
• →
• Interpretación
• →
• Verificación

Qué puedes usar esta semana

Lecturas de preparación

• [TRO] Cap. 5 “Understanding Encapsulation”: clases, constructores, this, modificadores de acceso y propiedades (automáticas y con lógica).
• [TRO] Cap. 6 “Understanding Inheritance and Polymorphism”: : Base, base(...), virtual y override, clases abstractas.
• [MSDN] Colecciones genéricas en C#: List<T> frente a arreglos.

Reading checkpoint

Clases, campos y propiedades

var ana = new Cuenta("Ana", 100m);
ana.Depositar(50m);
ana.Retirar(30m);
Console.WriteLine($"{ana.Titular}: {ana.Saldo:F2}");

try
{
    ana.Retirar(500m);
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"Rechazado: {ex.Message}");
}
// ana.Saldo = 1000m;   // no compila: el set es privado (CS0272)


public class Cuenta
{
    private readonly List<string> movimientos = new();

    public string Titular { get; }
    public decimal Saldo { get; private set; }

    public Cuenta(string titular, decimal saldoInicial = 0m)
    {
        if (saldoInicial < 0)
            throw new ArgumentException("el saldo inicial no puede ser negativo");
        Titular = titular;
        Saldo = saldoInicial;
    }

    public void Depositar(decimal monto)
    {
        if (monto <= 0)
            throw new ArgumentException("el depósito debe ser positivo");
        Saldo += monto;
        movimientos.Add($"depósito {monto:F2}");
    }

    public void Retirar(decimal monto)
    {
        if (monto <= 0)
            throw new ArgumentException("el retiro debe ser positivo");
        if (monto > Saldo)
            throw new InvalidOperationException($"saldo insuficiente ({Saldo:F2})");
        Saldo -= monto;
        movimientos.Add($"retiro {monto:F2}");
    }
}

Ana: 120.00
Rechazado: saldo insuficiente (120.00)

Arreglos y List<T>

decimal[] fijos = { 12.50m, 4.25m, 3.90m };        // arreglo: tamaño fijo
Console.WriteLine($"Arreglo: {fijos.Length} precios, primero {fijos[0]}");

var precios = new List<decimal> { 12.50m, 4.25m };
precios.Add(3.90m);
precios.Add(6.75m);
precios.Remove(4.25m);
precios.Insert(0, 1.99m);
Console.WriteLine($"Lista: {string.Join(", ", precios)} ({precios.Count} elementos)");

decimal total = 0;
foreach (decimal p in precios)
{
    total += p;
}
Console.WriteLine($"Total: {total:F2}  ¿Contiene 3.90? {precios.Contains(3.90m)}");

precios.Sort();
Console.WriteLine($"Ordenados: {string.Join(", ", precios)}");

var productos = new List<Producto>
{
    new Producto("A01", "Aceite", 12.50m, 40),
    new Producto("B07", "Arroz", 4.25m, 8),
};
foreach (var p in productos)
{
    if (p.Stock < 10) Console.WriteLine($"Reordenar {p.Nombre}");
}


public class Producto
{
    public string Codigo { get; }
    public string Nombre { get; }
    public decimal Precio { get; }
    public int Stock { get; set; }

    public Producto(string codigo, string nombre, decimal precio, int stock)
    {
        Codigo = codigo;
        Nombre = nombre;
        Precio = precio;
        Stock = stock;
    }
}

Arreglo: 3 precios, primero 12.50
Lista: 1.99, 12.50, 3.90, 6.75 (4 elementos)
Total: 25.14  ¿Contiene 3.90? True
Ordenados: 1.99, 3.90, 6.75, 12.50
Reordenar Arroz

Herencia y polimorfismo en C#

var planilla = new List<Empleado>
{
    new Empleado("Ana", 900m),
    new PorHora("Luis", 4.5m, 170),
    new Vendedor("Eva", 500m, 12000m),
};

decimal total = 0;
foreach (Empleado e in planilla)          // polimorfismo
{
    Console.WriteLine($"{e.Nombre,-6} {e.GetType().Name,-9} {e.CalcularPago(),9:N2}");
    total += e.CalcularPago();
}
Console.WriteLine($"Total planilla: {total:N2}");


public class Empleado
{
    public string Nombre { get; }
    protected decimal SalarioBase { get; }

    public Empleado(string nombre, decimal salarioBase)
    {
        Nombre = nombre;
        SalarioBase = salarioBase;
    }

    public virtual decimal CalcularPago() => SalarioBase;
}

public class PorHora : Empleado
{
    private readonly decimal tarifa;
    private readonly int horas;

    public PorHora(string nombre, decimal tarifa, int horas) : base(nombre, 0m)
    {
        this.tarifa = tarifa;
        this.horas = horas;
    }

    public override decimal CalcularPago()
    {
        decimal extra = Math.Max(0, horas - 160) * tarifa * 0.5m;
        return horas * tarifa + extra;
    }
}

public class Vendedor : Empleado
{
    private readonly decimal ventas;

    public Vendedor(string nombre, decimal salarioBase, decimal ventas) : base(nombre, salarioBase)
    {
        this.ventas = ventas;
    }

    public override decimal CalcularPago() => base.CalcularPago() + ventas * 0.05m;
}

Ana    Empleado     900.00
Luis   PorHora      787.50
Eva    Vendedor   1,100.00
Total planilla: 2,787.50

Tabla de traza

¿Compila? ¿Qué pasa?

Con la clase Cuenta de arriba y var c = new Cuenta("X", 100m);. Escribe el saldo final, no compila o el nombre de la excepción.

• Traza completa.

Ejercicios

var e = new Estudiante("Carla", "2026-0412");
e.AgregarNota(7.5m);
e.AgregarNota(5.0m);
e.AgregarNota(8.0m);
Console.WriteLine(e);
try { e.AgregarNota(11m); }
catch (ArgumentOutOfRangeException ex) { Console.WriteLine($"Error: {ex.ParamName} fuera de rango"); }


public class Estudiante
{
    private readonly List<decimal> notas = new();
    public string Nombre { get; }
    public string Carnet { get; }

    public Estudiante(string nombre, string carnet)
    {
        Nombre = nombre;
        Carnet = carnet;
    }

    public void AgregarNota(decimal nota)
    {
        if (nota < 0 || nota > 10)
            throw new ArgumentOutOfRangeException(nameof(nota));
        notas.Add(nota);
    }

    public decimal Promedio => notas.Count == 0 ? 0 : Math.Round(notas.Sum() / notas.Count, 2);
    public bool Aprobado => Promedio >= 6;

    public override string ToString() =>
        $"{Carnet} {Nombre}: {Promedio} ({(Aprobado ? "aprobado" : "en riesgo")})";
}

2026-0412 Carla: 6.83 (aprobado)
Error: nota fuera de rango

var metodos = new List<MetodoPago> { new Efectivo(), new Tarjeta(), new Transferencia() };
foreach (var m in metodos)
{
    Console.WriteLine($"{m.GetType().Name,-13} cobra {m.Cobrar(80m):F2}");
}


public abstract class MetodoPago
{
    public abstract decimal Comision(decimal monto);
    public decimal Cobrar(decimal monto) => monto + Comision(monto);
}

public class Efectivo : MetodoPago
{
    public override decimal Comision(decimal monto) => 0m;
}

public class Tarjeta : MetodoPago
{
    public override decimal Comision(decimal monto) => Math.Round(monto * 0.035m, 2);
}

public class Transferencia : MetodoPago
{
    public override decimal Comision(decimal monto) => monto < 100 ? 0.75m : 0m;
}

Efectivo      cobra 80.00
Tarjeta       cobra 82.80
Transferencia cobra 80.75

Práctica intensiva

Ejercicios rápidos con colecciones y herencia en C#, y un problema de modelado completo tipo examen final.

Ejercicios rápidos · ¿Qué imprime en C#?

Si no compila, escribe error.

var v = new List<int> { 3, 1, 2 };
v.Add(5);
Console.WriteLine(v.Count);

var v = new List<int> { 3, 1, 2 };
v.Sort();
Console.WriteLine(v[0]);

int[] a = { 4, 8, 15 };
Console.WriteLine(a.Length);

var v = new List<string> { "a" };
v.Add(5);

var v = new List<int> { 10, 20 };
Console.WriteLine(v.Contains(20));

A x = new B();
Console.WriteLine(x.F());

class A { public virtual string F() => "A"; }
class B : A { public override string F() => "B"; }

• Completé los ejercicios rápidos sin ejecutar el código.

Problema tipo examen

var inventario = new Inventario();
inventario.Agregar(new Producto("A01", "Aceite 1 L", 12.50m, 40));
inventario.Agregar(new Producto("B07", "Arroz 5 lb", 4.25m, 8));
inventario.Agregar(new Producto("C12", "Azúcar 5 lb", 3.90m, 0));

inventario.Vender("A01", 5);
try { inventario.Vender("B07", 20); }
catch (InvalidOperationException ex) { Console.WriteLine($"Rechazado: {ex.Message}"); }
try { inventario.Agregar(new Producto("A01", "Duplicado", 1m, 1)); }
catch (ArgumentException ex) { Console.WriteLine($"Rechazado: {ex.Message}"); }

Console.WriteLine($"Valor del inventario: {inventario.Valor():N2}");
foreach (var p in inventario.PorReordenar(10))
    Console.WriteLine($"Reordenar: {p.Nombre} ({p.Stock})");


public class Producto
{
    public string Codigo { get; }
    public string Nombre { get; }
    public decimal Precio { get; }
    public int Stock { get; private set; }

    public Producto(string codigo, string nombre, decimal precio, int stock)
    {
        if (precio <= 0) throw new ArgumentException("precio inválido");
        Codigo = codigo; Nombre = nombre; Precio = precio; Stock = stock;
    }

    public void Vender(int cantidad)
    {
        if (cantidad <= 0 || cantidad > Stock)
            throw new InvalidOperationException($"no hay {cantidad} de {Nombre} (quedan {Stock})");
        Stock -= cantidad;
    }
}

public class Inventario
{
    private readonly List<Producto> productos = new();

    public void Agregar(Producto p)
    {
        if (Buscar(p.Codigo) != null)
            throw new ArgumentException($"código repetido: {p.Codigo}");
        productos.Add(p);
    }

    public Producto? Buscar(string codigo)
    {
        foreach (var p in productos)
            if (p.Codigo == codigo) return p;
        return null;
    }

    public void Vender(string codigo, int cantidad)
    {
        Producto p = Buscar(codigo) ?? throw new ArgumentException($"no existe {codigo}");
        p.Vender(cantidad);
    }

    public decimal Valor()
    {
        decimal total = 0;
        foreach (var p in productos) total += p.Precio * p.Stock;
        return total;
    }

    public List<Producto> PorReordenar(int minimo)
    {
        var resultado = new List<Producto>();
        foreach (var p in productos)
            if (p.Stock < minimo) resultado.Add(p);
        return resultado;
    }
}

Rechazado: no hay 20 de Arroz 5 lb (quedan 8)
Rechazado: código repetido: A01
Valor del inventario: 471.50
Reordenar: Arroz 5 lb (8)
Reordenar: Azúcar 5 lb (0)

Guía de la defensa del proyecto

La sustentación es en esta semana: 15 minutos por equipo, 8 de demostración en vivo y 7 de preguntas individuales sobre el código. Vale el 25 % de la nota del proyecto, y quien no pueda explicar su código puede perder la nota del proyecto.

Antes del día

• Release v1.0 creado en GitHub (etiqueta y descripción de lo que incluye).
• El proyecto corre desde cero en una computadora del laboratorio siguiendo solo el README.
• Datos de ejemplo con al menos 20 registros; la app funciona apenas se abre.
• python -m pytest pasa el 100 %.
• Cada integrante ensayó explicar todos los módulos, no solo los suyos.
• Ensayaron un cambio en vivo (agregar una regla, un tipo nuevo, un campo) en menos de 5 minutos.

Guion sugerido para los 8 minutos

1. 1 min · El problema de negocio y quién usa el sistema.
2. 3 min · Demostración del flujo principal con datos reales, incluyendo un error manejado (dato inválido).
3. 2 min · Arquitectura: clases, módulos y por qué están así (diagrama o README).
4. 1 min · Pruebas corriendo en vivo.
5. 1 min · Valor para el negocio: qué automatiza, qué errores humanos evita, qué decisión mejora.

Banco de preguntas de todo el ciclo

Control 4 y rumbo al Final

El Control 4 es esta semana y el Examen Final la próxima (lógica en Python y fundamentos formales de C#). De esta semana:

• Escribir una clase en C# con campo privado, propiedad, constructor y método con validación.
• Usar List<T>: crear, agregar, recorrer, buscar.
• Escribir herencia con virtual/override y base(...).
• Traducir una clase de Python a C# y viceversa.
• Repasar el plan del Final.

Fuentes

• [TRO] Troelsen, A. y Japikse, P. (2022). Pro C# 10 with .NET 6, 11.ª ed. Caps. 5 y 6.
• [MSDN] Microsoft Learn. Clases · Colecciones.