Transición a C#: tipado estático y plataforma .NET

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. 1 “The Philosophy of .NET”: qué es el runtime (CLR), el lenguaje intermedio (IL/CIL), los ensamblados y por qué C# se compila.
• [TRO] Cap. 3 “Core C# Programming Constructs, Part I”: anatomía de un programa, tipos de datos, variables, conversiones, Parse/TryParse, condicionales y bucles.
• [MSDN] Guía de inicio rápido de C#: estructura del programa y tipos. Acceso libre.

Reading checkpoint

Console.WriteLine("Total")

Compilado vs. interpretado, y tu primer programa

Crear y ejecutar un proyecto

dotnet --version                 # comprobar la instalación del SDK
dotnet new console -o LaCeiba    # crea la carpeta y Program.cs
cd LaCeiba
dotnet run                       # compila y ejecuta

// Program.cs (.NET 6 o superior: instrucciones de nivel superior)
decimal precioUnitario = 12.50m;
int cantidad = 4;
const decimal TasaIva = 0.13m;

decimal subtotal = precioUnitario * cantidad;
decimal total = subtotal * (1 + TasaIva);
Console.WriteLine($"Subtotal: {subtotal:F2}");
Console.WriteLine($"Total:    {total:F2}");

Subtotal: 50.00
Total:    56.50

using System;

namespace LaCeiba
{
    class Program
    {
        static void Main(string[] args)
        {
            decimal precioUnitario = 12.50m;
            int cantidad = 4;
            Console.WriteLine($"Subtotal: {precioUnitario * cantidad:F2}");
        }
    }
}

Subtotal: 50.00

Tipos, variables y operadores

int cajas = 17;
int porCamion = 5;
Console.WriteLine(cajas / porCamion);          // división entera
Console.WriteLine(cajas % porCamion);
Console.WriteLine(cajas / (double)porCamion);  // conversión explícita (cast)

double d = 0.1 + 0.2;
decimal m = 0.1m + 0.2m;
Console.WriteLine(d == 0.3);
Console.WriteLine(m == 0.3m);

var nombre = "Aceite";         // var: el compilador deduce string
char inicial = nombre[0];
bool hayStock = true;
Console.WriteLine($"{nombre} empieza con {inicial}; ¿stock? {hayStock}");

decimal mitad = 2.665m;
Console.WriteLine(Math.Round(mitad, 2));                                   // redondeo bancario
Console.WriteLine(Math.Round(mitad, 2, MidpointRounding.AwayFromZero));   // redondeo comercial

3
2
3.4
False
True
Aceite empieza con A; ¿stock? True
2.66
2.67

Traducir de Python a C#

decimal total = 0;
int ventas = 0;

Console.WriteLine("Montos de venta (escriba 'fin' para cerrar):");
while (true)
{
    Console.Write("Monto: ");
    string? entrada = Console.ReadLine();
    if (entrada == null || entrada.Trim().ToLower() == "fin")
    {
        break;
    }

    if (decimal.TryParse(entrada, out decimal monto) && monto > 0)
    {
        total += monto;
        ventas++;
    }
    else
    {
        Console.WriteLine($"  '{entrada}' no es un monto válido.");
    }
}

Console.WriteLine($"Ventas: {ventas}  Total: {total:F2}");
if (ventas > 0)
{
    Console.WriteLine($"Promedio: {total / ventas:F2}");
}

Montos de venta (escriba 'fin' para cerrar):
Monto: 25.50
Monto: 100
Monto: diez
  'diez' no es un monto válido.
Monto: 74.50
Monto: fin
Ventas: 3  Total: 200.00
Promedio: 66.67

Funciones → métodos static

La tarifa de envío de las semanas 2 y 4, con tipo en cada parámetro y en el retorno:

Console.WriteLine(TarifaEnvio(1.01, "rural"));
Console.WriteLine(TarifaEnvio(20));
Console.WriteLine(TarifaEnvio(25));

static decimal TarifaEnvio(double pesoKg, string zona = "urbana")
{
    if (pesoKg <= 0 || pesoKg > 20)
    {
        return -1;                      // señal de "no se puede enviar"
    }

    decimal tarifa;
    if (pesoKg <= 1)
    {
        tarifa = 3.50m;
    }
    else if (pesoKg <= 5)
    {
        tarifa = 6.00m;
    }
    else
    {
        tarifa = 12.00m;
    }

    if (zona == "rural")
    {
        tarifa += 2.50m;
    }
    return tarifa;
}

8.50
12.00
-1

El parámetro opcional funciona igual que en Python (zona = "urbana"). Como decimal no puede ser null, aquí se usa −1 como señal; en la semana 11 verás una alternativa mejor (lanzar una excepción).

switch y for

string metodo = "tarjeta";
decimal monto = 80m;

decimal comision = metodo switch
{
    "efectivo" => 0m,
    "tarjeta" => monto * 0.035m,
    "transferencia" => monto < 100 ? 0.75m : 0m,
    _ => throw new ArgumentException($"método desconocido: {metodo}")
};
Console.WriteLine($"Comisión: {comision:F2}");

for (int mes = 1; mes <= 3; mes++)
{
    Console.WriteLine($"Mes {mes}: saldo {1000m * (decimal)Math.Pow(1.02, mes):F2}");
}

Comisión: 2.80
Mes 1: saldo 1020.00
Mes 2: saldo 1040.40
Mes 3: saldo 1061.21

El switch con => reemplaza cadenas largas de else if sobre un mismo valor; _ es “cualquier otro caso”. for (int mes = 1; mes <= 3; mes++) equivale a for mes in range(1, 4): inicio; condición; paso.

Errores de compilación frecuentes

Así se ve uno de verdad (compilado con .NET 8):

int cantidad = "4";
Console.WriteLine(cantidad);

Program.cs(1,16): error CS0029: Cannot implicitly convert type 'string' to 'int'

Se lee así: archivo Program.cs, línea 1, columna 16, código CS0029, y el mensaje (“no se puede convertir implícitamente string a int”). Busca el código en Microsoft Learn si no lo entiendes.

Tabla de traza

¿Qué imprime cada expresión en C#?

Escribe el valor como lo mostraría Console.WriteLine (los booleanos se muestran True/False).

• Traza completa.

Ejercicios

const decimal TasaIva = 0.13m;
const decimal TasaDescuento = 0.10m;
const decimal MinimoDescuento = 50m;

Console.WriteLine(CalcularTotal(12.50m, 4));
Console.WriteLine(CalcularTotal(8.00m, 3));
Console.WriteLine(CalcularTotal(30.00m, 2));

static decimal CalcularTotal(decimal precioUnitario, int cantidad)
{
    decimal subtotal = precioUnitario * cantidad;
    decimal descuento = subtotal >= MinimoDescuento ? subtotal * TasaDescuento : 0m;
    decimal total = (subtotal - descuento) * (1 + TasaIva);
    return Math.Round(total, 2, MidpointRounding.AwayFromZero);
}

50.85
27.12
61.02

decimal capital = 1000m;
const decimal Tasa = 0.08m;

decimal saldo = capital;
Console.WriteLine("Año   Interés      Saldo");
for (int anio = 1; anio <= 5; anio++)
{
    decimal interes = saldo * Tasa;
    saldo += interes;
    Console.WriteLine($"{anio,3}  {interes,8:F2}  {saldo,9:F2}");
}
Console.WriteLine($"Ganancia total: ${saldo - capital:N2}");

Año   Interés      Saldo
  1     80.00    1080.00
  2     86.40    1166.40
  3     93.31    1259.71
  4    100.78    1360.49
  5    108.84    1469.33
Ganancia total: $469.33

Console.WriteLine(ValidarClave("ceiba2026"));
Console.WriteLine(ValidarClave("ceibaceiba"));
Console.WriteLine(ValidarClave("12345678"));
Console.WriteLine(ValidarClave("Ceiba26"));

static string ValidarClave(string clave)
{
    if (clave.Length < 8)
    {
        return "Rechazada: mínimo 8 caracteres";
    }
    bool tieneLetra = false;
    bool tieneDigito = false;
    foreach (char c in clave)
    {
        if (char.IsLetter(c)) tieneLetra = true;
        else if (char.IsDigit(c)) tieneDigito = true;
        else return "Rechazada: solo letras y dígitos";
    }
    if (!tieneLetra) return "Rechazada: falta una letra";
    if (!tieneDigito) return "Rechazada: falta un dígito";
    return "Aceptada";
}

Aceptada
Rechazada: falta un dígito
Rechazada: falta una letra
Rechazada: mínimo 8 caracteres

int ventas = 3
decimal total = 250.5;
if (ventas > 0) {
    promedio = total / ventas;
}
Console.WriteLine("Promedio: " + promedio);

int ventas = 3;                       // CS1002: faltaba ;
decimal total = 250.5m;               // CS0664: literal decimal con m
decimal promedio = 0;                 // CS0103: no estaba declarada
                                      // CS0165: y necesita valor en todos los caminos
if (ventas > 0)
{
    promedio = total / ventas;
}
Console.WriteLine($"Promedio: {promedio:F2}");

Promedio: 83.50

Práctica intensiva

Ejercicios rápidos sobre las diferencias de C# con Python y problemas de traducción tipo examen.

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

Escribe lo que muestra Console.WriteLine. Si no compila, escribe error.

Console.WriteLine(9 / 4);

Console.WriteLine(9 / 4.0);

Console.WriteLine(9 % 4);

Console.WriteLine("Total: " + 5 + 5);

Console.WriteLine(5 + 5 + " unidades");

int x = 3;
x++;
x += 2;
Console.WriteLine(x);

int n = "7";

for (int i = 0; i < 3; i++)
    Console.Write(i);

Console.WriteLine(10 > 3 && 2 > 5);

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

Problemas tipo examen

string[] movimientos = { "+50", "-20", "abc", "-100", "+15", "-30" };
decimal saldo = 0m;
int rechazos = 0;

foreach (string mov in movimientos)
{
    if (!decimal.TryParse(mov, out decimal monto))
    {
        Console.WriteLine($"  '{mov}': formato inválido");
        rechazos++;
        continue;
    }
    if (saldo + monto < 0)
    {
        Console.WriteLine($"  {mov}: rechazado, saldo insuficiente ({saldo:F2})");
        rechazos++;
        continue;
    }
    saldo += monto;
}
Console.WriteLine($"Saldo final: {saldo:F2}  Rechazos: {rechazos}");

  'abc': formato inválido
  -100: rechazado, saldo insuficiente (30.00)
Saldo final: 15.00  Rechazos: 2

Console.WriteLine($"Cuota: {Cuota(1200m, 0.18m, 6):F2}");
Console.WriteLine($"Cuota sin interés: {Cuota(1200m, 0m, 12):F2}");
Console.WriteLine($"Meses para duplicar al 8 %: {MesesParaMeta(1000m, 0.08m / 12, 2000m)}");

static decimal Cuota(decimal monto, decimal tasaAnual, int meses)
{
    if (tasaAnual == 0)
    {
        return Math.Round(monto / meses, 2, MidpointRounding.AwayFromZero);
    }
    double i = (double)tasaAnual / 12;
    double cuota = (double)monto * i / (1 - Math.Pow(1 + i, -meses));
    return Math.Round((decimal)cuota, 2, MidpointRounding.AwayFromZero);
}

static int MesesParaMeta(decimal saldo, decimal tasaMensual, decimal meta)
{
    int meses = 0;
    while (saldo < meta)
    {
        saldo *= 1 + tasaMensual;
        meses++;
    }
    return meses;
}

Cuota: 210.63
Cuota sin interés: 100.00
Meses para duplicar al 8 %: 105

Proyecto integrador · Fase 6

Semana 10 · Documentación técnica, auditoría de IA y métricas. El proyecto sigue en Python.

Plantilla sugerida para la bitácora:

# Bitácora de transparencia técnica (uso de IA)

| Fecha | Integrante | Herramienta | Qué se pidió | Qué se aceptó | Qué se corrigió y cómo se verificó |
|---|---|---|---|---|---|
| 2026-10-02 | Ana | Asistente X | Estructura inicial de la clase Factura | El esqueleto de métodos | Tenía el saldo como atributo de clase (compartido); se movió a __init__ y se agregó la prueba test_facturas_independientes |
| 2026-10-05 | Luis | Asistente X | Lectura de CSV | csv.DictReader | No manejaba montos vacíos; se agregó try/except ValueError y el caso CB-04 de la matriz |

## Criterios de auditoría usados
1. ¿Ejecuta? 2. ¿Hace lo que se pidió? 3. ¿Usa las variables correctas?
4. ¿El resultado tiene sentido? 5. ¿Cómo se comprueba? 6. ¿Qué supuestos introduce?

Preguntas de defensa

Rumbo al Control 4 y al Final

El Examen Final evalúa lógica en Python y fundamentos formales de C#. De esta semana:

• Explicar compilado vs. interpretado, IL, CLR y JIT.
• Declarar variables con el tipo correcto (decimal para dinero).
• Predecir división entera, concatenación y redondeo en C#.
• Traducir condicionales, bucles y funciones de Python a C#.
• Leer un error de compilación: línea, código y significado.

Fuentes

• [TRO] Troelsen, A. y Japikse, P. (2022). Pro C# 10 with .NET 6, 11.ª ed. Caps. 1 y 3.
• [MSDN] Microsoft Learn. Paseo por C# · Errores del compilador.