Los métodos son funciones definidas en una clase. C# soporta características ricas de parámetros — argumentos opcionales/nombrados, modificadores ref/out/in, arreglos — y (múltiples métodos con el mismo nombre pero parámetros diferentes).
Los métodos son funciones definidas en una clase. C# soporta características ricas de parámetros — argumentos opcionales/nombrados, modificadores ref/out/in, arreglos — y (múltiples métodos con el mismo nombre pero parámetros diferentes).
paramspublic int Add(int a, int b) => a + b; // expression-bodied (concise)
public string Greet(string name, string greeting = "Hello") // default parameter
{
return $"{greeting}, {name}";
}
Greet("Ann"); // "Hello, Ann"
Greet("Ann", greeting: "Hi"); // named argument
Los métodos especifican un tipo de retorno, nombre y parámetros. Los parámetros por defecto hacen que los argumentos sean opcionales, y los argumentos nombrados te permiten pasar por nombre (más claro, puedes omitir opcionales).
// ref — pass by reference (method can modify the caller's variable)
void Increment(ref int x) { x++; }
int n = 5; Increment(ref n); // n is now 6
// out — for returning multiple values (must be assigned in the method)
bool TryParse(string s, out int result) { result = ...; return true; }
if (int.TryParse("42", out int value)) { } // the common TryX pattern
// in — pass by reference but READ-ONLY (performance for large structs)
void Process(in LargeStruct data) { }
out se usa ampliamente en el patrón TryParse (retornando un indicador de éxito más el resultado de forma segura); ref permite modificar la variable del llamador; in pasa estructuras grandes de forma eficiente sin copiar.
// params — variable number of arguments
int Sum(params int[] numbers) => numbers.Sum();
Sum(1, 2, 3, 4); // any number
// OVERLOADING — same name, different parameters
void Print(int x) { }
void Print(string s) { }
void Print(int x, int y) { }
Print(5); // calls the int version — resolved by argument types
La sobrecarga permite que múltiples métodos compartan un nombre, distinguidos por tipos/cantidad de parámetros — el compilador elige el que coincide. params acepta un número variable de argumentos.
Los métodos son los bloques de construcción del comportamiento en C#, y comprender sus características ricas de parámetros es importante para escribir código flexible y expresivo.
Saber cómo definir métodos (incluyendo la sintaxis concisa expresada en el cuerpo), usar parámetros opcionales y nombrados (para argumentos opcionales y llamadas legibles), y aplicar sobrecarga de métodos (mismo nombre, parámetros diferentes — para APIs intuitivas que manejan diferentes tipos de argumentos) es conocimiento cotidiano.
Los modificadores de parámetros son particularmente importantes de entender: out se usa ampliamente en el ubicuo patrón TryParse (int.TryParse(s, out var result) — retornando de forma segura un indicador de éxito y resultado sin excepciones, un patrón común e idiomático en C#), ref permite modificar la variable del llamador, e in pasa estructuras grandes por referencia para el rendimiento.
Comprender estos — métodos, las características de parámetros (opcionales/nombrados/params), sobrecarga para APIs flexibles, y los modificadores ref/out/in (especialmente el idioma basado en out-TryParse) — es fundamental tanto para escribir métodos en C# como para usar las muchas APIs de .NET que se basan en estas características.
Ya que los métodos y sus parámetros son centrales a todo código C#, y ya que características como la sobrecarga, parámetros opcionales, y el patrón TryX aparecen constantemente, dominarlos es conocimiento esencial y imprescindible para el desarrollo efectivo en C#.