C# Métodos (Methods)
Un método (Method) es un bloque de código que organiza un conjunto de declaraciones relacionadas para ejecutar una tarea específica. Es el mecanismo central en C# para implementarreutilización de códigoyencapsulación lógicaCada programa de C# tiene al menos unMainmétodo como punto de entrada del programa.
Usar un método requiere dos pasos:Definir el métodoyLlamar al método。
1. Definir un método
La sintaxis básica para definir un método en C# es la siguiente:
<modificador de acceso> <tipo de retorno> <nombre del método>(<lista de parámetros>)
{
cuerpo del método
}
Un método se compone de los siguientes elementos:
- Modificador de acceso(Access Modifier): controla la visibilidad del método, como
public、private、protected、internal。 - Tipo de retorno(Return Type): el tipo de dato del valor que devuelve el método. Si el método no devuelve ningún valor, se usa
void。 - Nombre del método(Method Name): identificador único del método, que sigue la convención de nomenclatura PascalCase (por ejemplo,
FindMax、GetUserName)。 - Lista de parámetros(Parameter List): las entradas que recibe el método, encerradas entre paréntesis. Los parámetros son opcionales; un método puede no tener parámetros.
- Cuerpo del método(Method Body): contiene el código que implementa la funcionalidad, encerrado entre llaves
{}.
La siguiente figura muestra la estructura completa de un método:
1.1 Primer ejemplo de método
A continuación se define unFindMaxmétodo que recibe dos enteros y devuelve el mayor de ellos:
Ejemplo
namespace MethodDemo
{
class NumberHelper
{
// Definir el método: recibe dos int, devuelve el mayor
public int FindMax(int num1, int num2)
{
if (num1 > num2)
return num1;
else
return num2;
}
static void Main(string[] args)
{
// Crear el objeto y llamar al método
NumberHelper helper = new NumberHelper();
int result = helper.FindMax(100, 200);
Console.WriteLine($"El valor máximo es: {result}"); // El valor máximo es: 200
}
}
}
Flujo de llamada del método:
Llamada entre clases:Siempre que el método se declare como
public, se puede llamar desde otras clases creando una instancia. Esta es la base de la reutilización de código en la programación orientada a objetos.
2. Formas de pasar parámetros
C# ofrece tres formas de pasar parámetros a un método. Su diferencia fundamental radica ensi comparten memoria:
| Forma | Palabra clave | Comportamiento | Escenario típico |
|---|---|---|---|
| Paso por valor | (ninguna) | Copia el valor del parámetro; las modificaciones dentro del método no afectan a la variable original | La mayoría de las llamadas a métodos (predeterminado) |
| Paso por referencia | ref |
Pasa la referencia de la variable; las modificaciones dentro del método cambian la variable original | Se necesita modificar una variable externa (por ejemplo, intercambiar valores) |
| Parámetro de salida | out |
Similar a ref, pero el método debe asignar un valor; no se necesita inicializar antes de la llamada | El método necesita devolver varios valores |
2.1 Paso por valor (predeterminado)
El paso por valor es la forma predeterminada. El valor del argumento secopiaal parámetro; las modificaciones al parámetro dentro del método no afectan a la variable original:
Ejemplo
namespace ParameterDemo
{
class Program
{
// Paso por valor: x e y son copias de a y b
public void Swap(int x, int y)
{
int temp = x;
x = y;
y = temp;
Console.WriteLine($" Dentro del método: x={x}, y={y}"); // Intercambio exitoso
}
static void Main(string[] args)
{
var p = new Program();
int a = 100, b = 200;
Console.WriteLine($"Antes de llamar: a={a}, b={b}");
p.Swap(a, b);
Console.WriteLine($"Después de llamar: a={a}, b={b}"); // ¡a y b no han cambiado!
}
}
}
调用前:a=100, b=200 方法内:x=200, y=100 调用后:a=100, b=200
2.2 Paso por referencia (ref)
Usa larefpalabra clave para pasar lareferencia(dirección de memoria) de la variable; las modificaciones al parámetro dentro del método afectan directamente a la variable original. Ten en cuenta que al llamar también se debe añadirref:
Ejemplo
namespace ParameterDemo
{
class Program
{
// Paso por referencia: x e y referencian directamente la memoria de a y b
public void Swap(ref int x, ref int y)
{
int temp = x;
x = y;
y = temp;
}
static void Main(string[] args)
{
var p = new Program();
int a = 100, b = 200;
Console.WriteLine($"Antes de llamar: a={a}, b={b}");
p.Swap(ref a, ref b); // Al llamar también se debe agregar ref
Console.WriteLine($"Después de llamar: a={a}, b={b}"); // ¡Intercambio exitoso!
}
}
}
调用前:a=100, b=200 调用后:a=200, b=100
Diferencia entre ref y out:
refrequiere que la variableya esté inicializada antes de pasarse;outno lo requiere, pero dentro del métodose debe asignar un valor al parámetro outantes de poder usarlo.
2.3 Parámetro de salida (out)
outEl parámetro out permite que el métododevuelva varios valores. A diferencia deref, la variable no necesita inicializarse antes de la llamada, pero el método debe asignarle un valor en su interior:
Ejemplo
namespace ParameterDemo
{
class Program
{
// Parámetro out: el método se encarga de asignar el valor
public void GetValues(out int x, out int y)
{
Console.Write("Ingrese el primer valor:");
x = Convert.ToInt32(Console.ReadLine());
Console.Write("Ingrese el segundo valor:");
y = Convert.ToInt32(Console.ReadLine());
// Nota: antes de que el método termine, se debe asignar un valor a todos los parámetros out; de lo contrario, error de compilación
}
// Ejemplo práctico: patrón TryParse
public bool TryDivide(int a, int b, out double result)
{
if (b == 0)
{
result = 0;
return false; // Divisor es cero
}
result = (double)a / b;
return true;
}
static void Main(string[] args)
{
var p = new Program();
// El parámetro out no necesita inicialización
int a, b;
p.GetValues(out a, out b);
Console.WriteLine($"a={a}, b={b}");
// Patrón TryParse
if (p.TryDivide(10, 3, out double res))
Console.WriteLine($"10 / 3 = {res:F2}"); // 3.33
}
}
}
Desde C# 7.0, se puededeclarar en líneala variable out, lo que hace que el código sea más conciso:
// C# 7.0+ 内联声明
if (int.TryParse("123", out int number))
Console.WriteLine($"解析成功:{number}");
3. Métodos recursivos
La recursión (Recursion) consiste en que un métodose llama a sí mismo. Todo método recursivo necesita dos elementos:
- Caso base(Base Case): la condición que termina la recursión, para evitar la recursión infinita
- Paso recursivo(Recursive Step): descompone el problema en subproblemas más pequeños
Ejemplo clásico: calcular el factorial $$n! = n \times (n-1)!$$:
Ejemplo
namespace RecursionDemo
{
class Program
{
// Calcular el factorial de forma recursiva
public int Factorial(int n)
{
// Caso base: 0! = 1, 1! = 1
if (n <= 1)
return 1;
// Paso recursivo: n! = n × (n-1)!
return n * Factorial(n - 1);
}
static void Main(string[] args)
{
var p = new Program();
Console.WriteLine($"6! = {p.Factorial(6)}"); // 720
Console.WriteLine($"7! = {p.Factorial(7)}"); // 5040
Console.WriteLine($"8! = {p.Factorial(8)}"); // 40320
}
}
}
6! = 720 7! = 5040 8! = 40320
Proceso de expansión de las llamadas recursivas:
Factorial(4) = 4 × Factorial(3) = 4 × 3 × Factorial(2) = 4 × 3 × 2 × Factorial(1) = 4 × 3 × 2 × 1 = 24
Nota:Cuando la profundidad de recursión es demasiado grande, puede causar
StackOverflowException. Para escenarios sensibles al rendimiento, considera usar un bucle en su lugar.
4. Más características de los métodos
4.1 Parámetros predeterminados y parámetros con nombre
C# permite establecer para los parámetrosvalores predeterminados, que pueden omitirse al llamar. Junto conparámetros con nombre, también se pueden omitir algunos parámetros y especificar solo los siguientes:
Ejemplo
namespace MethodFeatures
{
class Program
{
// Parámetro opcional: power predeterminado a 2
static double Power(double baseNum, int power = 2)
{
double result = 1;
for (int i = 0; i < power; i++)
result *= baseNum;
return result;
}
// Varios parámetros opcionales
static void PrintInfo(string name, int age = 18, string city = "Desconocido")
{
Console.WriteLine($"{name}, {age} años, {city}");
}
static void Main(string[] args)
{
// Usando parámetros opcionales
Console.WriteLine(Power(3)); // 9.0 (usando power predeterminado = 2)
Console.WriteLine(Power(3, 3)); // 27.0
// Parámetro con nombre: omite age, solo especifica city
PrintInfo("Xiaoming", city: "Beijing");
// Salida: Xiaoming, 18 años, Beijing
// Los parámetros con nombre pueden ir en cualquier orden
PrintInfo(city: "Shanghai", name: "Xiaohong", age: 25);
// Salida: Xiaohong, 25 años, Shanghai
}
}
}
4.2 Métodos con cuerpo de expresión
Cuando el cuerpo del método tiene solo una declaración, se puede usar=>una sintaxis simplificada (C# 6.0+):
// 传统写法
public int Add(int a, int b)
{
return a + b;
}
// 表达式体写法(等价)
public int Add(int a, int b) => a + b;
4.3 Sobrecarga de métodos (Overloading)
En la misma clase puede habervarios métodos con el mismo nombre, siempre que la lista de parámetros sea diferente (tipo, cantidad u orden de parámetros):
Ejemplo
namespace MethodFeatures
{
class Calculator
{
// Sobrecarga 1: sumar dos ints
public int Add(int a, int b) => a + b;
// Sobrecarga 2: sumar tres ints
public int Add(int a, int b, int c) => a + b + c;
// Sobrecarga 3: sumar dos doubles
public double Add(double a, double b) => a + b;
static void Main(string[] args)
{
var calc = new Calculator();
Console.WriteLine(calc.Add(1, 2)); // 3 (llama a la sobrecarga 1)
Console.WriteLine(calc.Add(1, 2, 3)); // 6 (llama a la sobrecarga 2)
Console.WriteLine(calc.Add(1.5, 2.5)); // 4.0 (llama a la sobrecarga 3)
}
}
}
Resumen
| Característica | Sintaxis | Descripción |
|---|---|---|
| Definir métodos | int Add(int a, int b) { ... } |
Especifica el tipo de retorno, el nombre del método y los parámetros |
| Sin valor de retorno | void DoSomething() { ... } |
voidIndica que no devuelve ningún valor |
| Paso por valor | void Foo(int x) |
Forma predeterminada; modificar el parámetro no afecta al argumento |
| Paso por referencia | void Foo(ref int x) |
Memoria compartida; las modificaciones se reflejan en el argumento |
| Parámetro de salida | void Foo(out int x) |
Debe asignarse dentro del método; puede devolver varios valores |
| Parámetros opcionales | void Foo(int x = 10) |
Pueden omitirse al llamar; se usan valores predeterminados |
| Parámetros con nombre | Foo(city: "北京") |
Especificar parámetros por nombre, sin necesidad de seguir el orden |
| Cuerpo de expresión | int Add(int a, int b) => a + b; |
Abreviatura para métodos de una sola línea (C# 6.0+) |
| Sobrecarga de métodos | Mismo nombre, diferentes parámetros | El compilador elige automáticamente según la lista de parámetros |