Métodos y uso de parámetros en C#

En C#, los métodos se utilizan para organizar y reutilizar código repetitivo. Un método realiza una tarea específica y puede ser llamado muchas veces dentro de un programa. Esto ayuda a evitar la duplicación de código y mejora la legibilidad.

Definir y llamar métodos

Un método se define con un tipo de retorno, un nombre y parámetros opcionales. Por ejemplo, el siguiente método imprime un mensaje simple:

static void Saludar()
{
    Console.WriteLine("¡Hola!");
}

static void Main()
{
    Saludar(); // llamada al método
}

// Salida:
¡Hola!

Métodos con parámetros

Los métodos pueden recibir valores externos. Estos valores se llaman parámetros. En el siguiente ejemplo, se pasa un parámetro «nombre» y el mensaje de saludo se personaliza:

static void Saludar(string nombre)
{
    Console.WriteLine("¡Hola " + nombre + "!");
}

static void Main()
{
    Saludar("Ana");
    Saludar("Luis");
}

// Salida:
¡Hola Ana!
¡Hola Luis!

Métodos que devuelven valores

Los métodos pueden realizar una operación y devolver un resultado. Para ello, se define un tipo de retorno (int, string, etc.). El siguiente ejemplo muestra un método que suma dos números:

static int Sumar(int a, int b)
{
    return a + b;
}

static void Main()
{
    int resultado = Sumar(5, 7);
    Console.WriteLine("Suma: " + resultado);
}

// Salida:
Suma: 12

Parámetros predeterminados

Los parámetros pueden tener valores predeterminados. Si no se pasa ningún valor al llamar al método, se usará ese valor:

static void ImprimirMensaje(string texto = "Mensaje predeterminado")
{
    Console.WriteLine(texto);
}

static void Main()
{
    ImprimirMensaje("¡Hola mundo!");
    ImprimirMensaje();
}

// Salida:
¡Hola mundo!
Mensaje predeterminado

Parámetro vs Argumento

Un parámetro es el nombre usado en la definición del método. Un argumento es el valor real que se pasa al llamar al método.

static void Cuadrado(int numero) // parámetro: numero
{
    Console.WriteLine(numero * numero);
}

static void Main()
{
    Cuadrado(4); // argumento: 4
}

// Salida:
16

Sobrecarga (Overloading)

Se pueden definir métodos con el mismo nombre pero con un número o tipos de parámetros diferentes. A esto se le llama sobrecarga de métodos:

static int Multiplicar(int a, int b)
{
    return a * b;
}

static int Multiplicar(int a, int b, int c)
{
    return a * b * c;
}

static void Main()
{
    Console.WriteLine(Multiplicar(3, 4));
    Console.WriteLine(Multiplicar(2, 3, 4));
}

// Salida:
12
24

Recursividad

Cuando un método se llama a sí mismo, se denomina recursividad. Cada recursión debe tener una condición de salida, de lo contrario, el ciclo continuará indefinidamente.

static int Factorial(int n)
{
    if (n <= 1)
        return 1; // condición de salida
    return n * Factorial(n - 1); // llamada recursiva
}

static void Main()
{
    Console.WriteLine(Factorial(5)); // 120
}

Parámetros ref y out

En C#, las palabras clave ref y out permiten pasar parámetros por referencia. Esto significa que los cambios realizados dentro del método también se reflejan fuera.

// Ejemplo ref
static void Incrementar(ref int numero)
{
    numero++;
}

// Ejemplo out
static void Leer(out int resultado)
{
    resultado = 42;
}

static void Main()
{
    int x = 5;
    Incrementar(ref x);
    Console.WriteLine(x); // 6

    int y;
    Leer(out y);
    Console.WriteLine(y); // 42
}

Parámetros múltiples con params

La palabra clave params permite que un método reciba un número variable de parámetros. Se puede pasar un arreglo o valores individuales.

Ejemplo: Sumar números

static int Sumar(params int[] numeros)
{
    int suma = 0;
    foreach (int n in numeros)
        suma += n;
    return suma;
}

static void Main()
{
    Console.WriteLine(Sumar(1, 2, 3));       // 6
    Console.WriteLine(Sumar(5, 10, 15, 20)); // 50
}

Ejemplo: Unir palabras

static string Unir(params string[] palabras)
{
    return string.Join(" ", palabras);
}

static void Main()
{
    Console.WriteLine(Unir("C#", "es", "un", "lenguaje", "potente."));
    // Salida: C# es un lenguaje potente.
}

Funciones locales

A partir de C# 7.0, se pueden definir métodos dentro de otro método. Estos se llaman funciones locales. Ayudan a escribir un código más claro y organizado.

static void Main()
{
    int Multiplicar(int a, int b) // función local
    {
        return a * b;
    }

    Console.WriteLine(Multiplicar(3, 4)); // 12
}

TL;DR