Métodos y funciones en C#

Qué es un método#

Un método (o función) es un bloque de código con nombre que puedes ejecutar cuando quieras. Sirve para no repetirte: escribes algo una vez y lo llamas desde donde haga falta. Recibe datos de entrada (parámetros) y puede devolver un resultado.

// Un método que no devuelve nada (void)
void SaludarJugador(string nombre)
{
    Debug.Log("Bienvenido, " + nombre);
}

// Un método que devuelve un int
int Sumar(int a, int b)
{
    return a + b;
}

// Llamarlos:
SaludarJugador("Ana");
int total = Sumar(4, 5);   // total = 9

Anatomía de un método#

texto

int    Sumar   (int a, int b)   { ... }
 │       │          │
tipo   nombre    parámetros
de
retorno

Tipo de retorno: qué devuelve (int, bool, Vector3...). void = no devuelve nada.
Nombre: en PascalCase y descriptivo (CalcularDaño, no hacer).
Parámetros: los datos que necesita para trabajar.
return: entrega el resultado y termina el método.

Parámetros opcionales y con nombre#

Puedes dar valores por defecto y llamar indicando el nombre:

void Disparar(int daño = 10, float alcance = 100f)
{
    // ...
}

Disparar();                 // usa 10 y 100
Disparar(25);               // daño 25, alcance por defecto
Disparar(alcance: 50f);     // por nombre: solo cambia el alcance

Sobrecarga: mismo nombre, distintos parámetros#

Puedes tener varios métodos con el mismo nombre si se diferencian en los parámetros. C# elige el correcto según cómo lo llames:

void Mostrar(int numero)   => Debug.Log("Número: " + numero);
void Mostrar(string texto) => Debug.Log("Texto: " + texto);

Mostrar(5);         // usa el primero
Mostrar("hola");    // usa el segundo

Devolver varios valores: out#

Un método devuelve un valor con return, pero puede entregar más con parámetros out. Lo usa, por ejemplo, Physics.Raycast y TryGetComponent:

bool Dividir(int a, int b, out int resultado)
{
    if (b == 0) { resultado = 0; return false; }
    resultado = a / b;
    return true;
}

if (Dividir(10, 2, out int r))
    Debug.Log(r);   // 5

out vs ref

out: el método debe asignar el valor (sirve para "devolver" datos extra). ref: pasas una variable ya existente para que el método la modifique. En la práctica del día a día en Unity, verás out mucho más (en TryGetComponent, Raycast, TryParse).

params: número variable de argumentos#

int SumarTodos(params int[] numeros)
{
    int total = 0;
    foreach (int n in numeros) total += n;
    return total;
}

SumarTodos(1, 2, 3);        // 6
SumarTodos(4, 5, 6, 7, 8);  // 30

Forma compacta: expression body#

Para métodos de una sola línea, C# permite =>:

int Doble(int x) => x * 2;
void Log(string m) => Debug.Log(m);

Es lo mismo que un método con { return ...; }, más corto. Lo has visto por toda esta documentación.

Buenas prácticas#

Un método, una tarea. Si hace muchas cosas, divídelo.
Nombres que digan qué hacen: CalcularDaño, no proc.
Cortos: si un método no cabe en la pantalla, probablemente pida trocearse.
Evita repetir código: si copias y pegas un bloque, conviértelo en un método.

Errores frecuentes#

Olvidar el return en un método que no es void.
Que el tipo devuelto no coincida con el declarado.
Métodos gigantes que hacen de todo (divídelos).
Confundir declarar el método (definirlo) con llamarlo (ejecutarlo).

Ponte a prueba#

📝 Pon a prueba lo aprendido

Resumen#

Un método agrupa código reutilizable con un nombre: recibe parámetros, puede devolver un valor (return) o no (void), admite sobrecargas (mismo nombre, distintos parámetros), parámetros opcionales, out/ref para valores extra y params para cantidad variable. Escríbelos cortos, con nombres claros y una sola responsabilidad. Son la base para organizar cualquier clase.