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, comopublic、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 usavoid。
  • 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:

Análisis de la estructura de un método en C# public int FindMax ( int num1, int num2 ) Modificador de acceso public / private Controla la visibilidad Tipo de retorno int / void Tipo de dato del valor de retorno Nombre del método PascalCase Identificador único Lista de parámetros Tipo + nombre Varios separados por comas { Cuerpo del método: código que implementa la funcionalidad } Cuerpo del método (Method Body) Firma completa del método: public int FindMax(int a, int b) Modificador → Tipo de retorno → Nombre del método → Lista de parámetros

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

using System;

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:

Flujo de llamada del método Llamador FindMax(100, 200) Argumentos El método recibe num1=100, num2=200 Ejecuta el cuerpo del método Compara y devuelve el resultado Retorna Valor de retorno result = 200 1. Llamar al método, pasar argumentos → 2. Los parámetros reciben el valor → 3. Ejecutar el cuerpo del método → 4. Devolver el resultado al llamador

Llamada entre clases:Siempre que el método se declare comopublic, 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:

Comparación de las tres formas de paso de parámetros Paso por valor (predeterminado) Llamador a = 100 Copia Dentro del método x = 100 Espacios de memoria independientes Modificar x no afecta a a Después de swap(a, b), a y b no cambian Sin necesidad de palabras clave adicionales void Swap(int x, int y) Paso por referencia (ref) Llamador a = 200 Misma dirección Dentro del método ref x = 200 Comparten la misma memoria Modificar x cambia a Después de swap(ref a, ref b), el intercambio tiene éxito Requiere la palabra clave ref void Swap(ref int x, ref int y) Parámetro de salida (out) Llamador a = 5 ← Salida Dentro del método out x = 5 El método debe asignar un valor al parámetro out No requiere inicialización antes de la llamada Puede devolver varios valores Requiere la palabra clave out void Calc(out int x, out int y)
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

using System;

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

using System;

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

using System;

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

using System;

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 causarStackOverflowException. 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

using System;

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

using System;

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
Otras extensiones