Métodos são funções definidas em uma classe. C# oferece recursos avançados de parâmetros — argumentos opcionais/nomeados, modificadores ref/out/in, arrays — e (múltiplos métodos com o mesmo nome mas parâmetros diferentes).
Métodos são funções definidas em uma classe. C# oferece recursos avançados de parâmetros — argumentos opcionais/nomeados, modificadores ref/out/in, arrays — e (múltiplos métodos com o mesmo nome mas 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
Métodos especificam um tipo de retorno, nome e parâmetros. Parâmetros padrão tornam argumentos opcionais, e argumentos nomeados permitem passar por nome (mais claro, pode pular opcionais).
// 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 é amplamente usado no padrão TryParse (retornando um sinalizador de sucesso mais o resultado com segurança); ref permite modificar a variável do chamador; in passa structs grandes com eficiência sem cópia.
// 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
Sobrecarga permite que múltiplos métodos compartilhem um nome, diferenciados pelos tipos/quantidade de parâmetros — o compilador escolhe o que corresponde. params aceita um número variável de argumentos.
Métodos são os blocos de construção do comportamento em C#, e compreender seus recursos avançados de parâmetros é importante para escrever código flexível e expressivo.
Saber como definir métodos (incluindo a sintaxe concisa com corpo de expressão), usar parâmetros padrão e nomeados (para argumentos opcionais e chamadas legíveis), e aplicar sobrecarga de métodos (mesmo nome, parâmetros diferentes — para APIs intuitivas que tratam diferentes tipos de argumento) é conhecimento do dia a dia.
Os modificadores de parâmetro são particularmente importantes de compreender: out é amplamente usado no padrão TryParse onipresente (int.TryParse(s, out var result) — retornando com segurança um sinalizador de sucesso e resultado sem exceções, um padrão idiomático comum em C#), ref permite modificar a variável do chamador, e in passa structs grandes por referência para desempenho.
Compreender estes — métodos, os recursos de parâmetros (padrão/nomeado/params), sobrecarga para APIs flexíveis, e os modificadores ref/out/in (especialmente o idioma baseado em out do TryParse) — é fundamental tanto para escrever métodos em C# quanto para usar as muitas APIs .NET que dependem desses recursos.
Como métodos e seus parâmetros são centrais em todo código C#, e como recursos como sobrecarga, parâmetros opcionais e o padrão TryX aparecem constantemente, dominá-los é conhecimento essencial e obrigatório para desenvolvimento C# eficaz.