¿Qué son los métodos y cómo crearlos en C#?

Un método es un bloque de código con nombre que realiza una tarea específica y puede reutilizarse cuantas veces necesites.

En lugar de escribir el mismo código repetido en varios lugares, lo encapsulas en un método. Así tu programa es más limpio, más fácil de mantener y más fácil de corregir.

Estructura de un método en C#

Todo método sigue el mismo esquema base:

[modificador] [tipo de retorno] NombreDelMetodo([parámetros])
{
    // cuerpo del método
    return valor; // solo si el tipo de retorno no es void
}

Cada parte tiene un papel:

• Modificador: indica quién puede usar el método. El más común es static en programas básicos.
• Tipo de retorno: el tipo de dato que el método devuelve (int, double, string). Si no devuelve nada, usas void.
• NombreDelMetodo: usa PascalCase; por ejemplo, CalcularIVA.
• Parámetros: los datos que el método necesita para trabajar. Van entre paréntesis.

Tu primer método: sin parámetros ni retorno

El tipo más sencillo es un método void sin parámetros.

static void MostrarBienvenida()
{
    Console.WriteLine("Bienvenido al sistema de nómina FEMSA.");
}

Para ejecutarlo, lo llamas por su nombre:

MostrarBienvenida();

Eso imprime en pantalla:

Bienvenido al sistema de nómina FEMSA.

Este tipo de método es útil para mostrar mensajes o encabezados repetitivos.

Métodos con parámetros

Un parámetro es una variable que el método recibe desde afuera para usarla en su cuerpo.

Supón que Bimbo necesita calcular el IVA de cualquier producto. En lugar de repetir la fórmula, creas un método:

static void MostrarIVA(double precio)
{
    double iva = precio * 0.16;
    Console.WriteLine("IVA: $" + iva);
}

Lo llamas así:

MostrarIVA(500);
MostrarIVA(1200);

Salida:

IVA: $80
IVA: $192

Puedes pasar tantos parámetros como necesites, separados por coma.

Métodos con valor de retorno

Un método con retorno devuelve un resultado que puedes guardar en una variable o usar directamente.

Este es el tipo más poderoso. Mira cómo calcular el IVA y devolver el resultado:

static double CalcularIVA(double precio)
{
    return precio * 0.16;
}

Ahora puedes usar el resultado en otras operaciones:

double precioProducto = 850;
double iva = CalcularIVA(precioProducto);
double total = precioProducto + iva;
Console.WriteLine("Precio: $" + precioProducto);
Console.WriteLine("IVA: $" + iva);
Console.WriteLine("Total: $" + total);

Salida:

Precio: $850
IVA: $136
Total: $986

La palabra clave return termina el método inmediatamente y entrega el valor indicado.

Ejemplo práctico: sistema de descuentos de Liverpool

Liverpool aplica descuentos según el monto de compra. Crea un método que calcule el descuento correcto:

static double CalcularDescuento(double monto)
{
    if (monto >= 5000)
        return monto * 0.15;
    else if (monto >= 2000)
        return monto * 0.10;
    else
        return monto * 0.05;
}

Y un segundo método que muestre el resumen completo:

static void MostrarResumenCompra(double monto)
{
    double descuento = CalcularDescuento(monto);
    double total = monto - descuento;
    Console.WriteLine("Compra original: $" + monto);
    Console.WriteLine("Descuento aplicado: $" + descuento);
    Console.WriteLine("Total a pagar: $" + total);
}

Observa que MostrarResumenCompra llama a CalcularDescuento internamente. Un método puede llamar a otro. Así se construyen programas bien organizados.

Prueba con dos clientes:

MostrarResumenCompra(6000);
Console.WriteLine("---");
MostrarResumenCompra(1500);

Salida:

Compra original: $6,000
Descuento aplicado: $900
Total a pagar: $5,100
---
Compra original: $1,500
Descuento aplicado: $75
Total a pagar: $1,425

Ejemplo avanzado: cálculo de nómina

Un sistema de nómina básico para Mercado Libre necesita calcular el salario neto después de deducciones del IMSS. Crea tres métodos separados:

static double CalcularDeduccionIMSS(double salarioBruto)
{
    return salarioBruto * 0.0275; // cuota obrera aproximada
}

static double CalcularSalarioNeto(double salarioBruto)
{
    double imss = CalcularDeduccionIMSS(salarioBruto);
    return salarioBruto - imss;
}

static void ImprimirRecibo(string nombre, double salarioBruto)
{
    double imss = CalcularDeduccionIMSS(salarioBruto);
    double neto = CalcularSalarioNeto(salarioBruto);
    Console.WriteLine("Empleado: " + nombre);
    Console.WriteLine("Salario bruto: $" + salarioBruto);
    Console.WriteLine("Deducción IMSS: $" + imss);
    Console.WriteLine("Salario neto: $" + neto);
}

Llamas al programa con datos reales:

ImprimirRecibo("Ana Torres", 18500);
Console.WriteLine("---");
ImprimirRecibo("Luis Ramírez", 12000);

Salida:

Empleado: Ana Torres
Salario bruto: $18,500
Deducción IMSS: $508.75
Salario neto: $17,991.25
---
Empleado: Luis Ramírez
Salario bruto: $12,000
Deducción IMSS: $330
Salario neto: $11,670

Cada método hace una sola cosa. Esa es la regla de oro al diseñar métodos.

Tabla de referencia: tipos de métodos

Errores comunes

Error 1: olvidar el return en métodos con tipo de retorno.

// MAL
static double CalcularIVA(double precio)
{
    double iva = precio * 0.16;
    // Falta el return — el compilador lanzará un error
}

// BIEN
static double CalcularIVA(double precio)
{
    return precio * 0.16;
}

Si declaras un tipo de retorno distinto de void, el compilador te exige un return en todos los caminos posibles del método.

Error 2: usar el nombre del método con mayúsculas incorrectas al llamarlo.

C# distingue entre mayúsculas y minúsculas. Si el método se llama CalcularIVA, llamarlo como calcularIVA() o calculariva() genera un error de compilación. Siempre respeta el nombre exacto.

Error 3: pasar argumentos en el orden equivocado.

static void MostrarDato(string nombre, double salario)
{
    Console.WriteLine(nombre + ": $" + salario);
}

// MAL: se pasan al revés
MostrarDato(18500, "Carlos"); // Error de tipos

// BIEN
MostrarDato("Carlos", 18500);

Los argumentos deben coincidir en orden y en tipo con los parámetros declarados.

Error 4: declarar variables dentro del método y tratar de usarlas fuera.

Las variables declaradas dentro de un método solo existen ahí. Ese concepto se llama alcance (scope). Si necesitas el resultado fuera, usa return.

Buenas prácticas al nombrar métodos

• Usa verbos que describan la acción: Calcular, Mostrar, Obtener, Validar.
• Usa PascalCase: primera letra de cada palabra en mayúscula.
• El nombre debe describir exactamente lo que hace el método, sin ambigüedades.
• Evita nombres genéricos como Metodo1 o HacerCosas.

Puntos clave

• Un método agrupa código reutilizable bajo un nombre. Evita repetir la misma lógica en varios lugares del programa.
• El tipo de retorno define qué devuelve el método. Usa void si no necesita devolver nada; usa double, int o string si necesita entregar un resultado.
• Los parámetros son los datos de entrada del método. Declara solo los que realmente necesitas.
• Un método debe hacer una sola cosa. Si hace demasiado, divídelo en métodos más pequeños.
• Nombra tus métodos con verbos en PascalCase para que cualquier persona pueda entender qué hace el código sin necesidad de leerlo completo.