Assinaturas e retornos; com corpo de expressão; opcionais/nomeados; ref/out; sobrecarga
Defina assinaturas de métodos e valores de retorno, use métodos com corpo de expressão e parâmetros opcionais/nomeados e entenda ref/out e a sobrecarga. Observação: não há funções locais no C# 6.
Assinaturas e retornos; com corpo de expressão; opcionais/nomeados; ref/out; sobrecarga é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 3 aulas no total.
Fundamentos dos métodos
Objetivo: definir métodos limpos: assinatura (nome, parâmetros, tipo de retorno), corpos concisos e comportamento previsível.
- Valores de retorno
- Métodos com corpo de expressão
- Parâmetros opcionais e nomeados
Assinaturas e retornos
Um método tem um nome, parâmetros e um tipo de retorno. Mantenha os nomes claros e específicos.
using System;
public class MathUtil
{
// Signature: name Add, parameters (int a, int b), return int
public static int Add(int a, int b)
{
return a + b;
}
}
public class Program
{
public static void Main(string[] args)
{
int s = MathUtil.Add(2, 3);
Console.WriteLine("Sum = " + s);
}
}
Métodos com corpo de expressão
Métodos com corpo de expressão usam => para pequenos auxiliares claros.
using System;
public static class FormatUtil
{
// Expression-bodied method (C# 6): concise one-liner
public static string Greet(string name) => "Hello, " + name + "!";
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(FormatUtil.Greet("Ada"));
}
}
Opcionais e nomeados
Use parâmetros opcionais para valores padrão adequados e argumentos nomeados para obter clareza no local da chamada.
using System;
public static class Logger
{
// Optional parameter: times has a default
public static void Log(string message, int times = 1)
{
for (int i = 0; i < times; i = i + 1)
{
Console.WriteLine(message);
}
}
}
public class Program
{
public static void Main(string[] args)
{
Logger.Log("One time"); // uses default
Logger.Log(message: "Twice", times: 2); // named arguments
}
}
Fundamentos de ref e out
ref: a variável deve ter sido atribuída antes da chamada. out: o método deve atribuir um valor antes de retornar.
using System;
public static class RefOutDemo
{
public static void Increment(ref int x)
{
x = x + 1; // modifies caller's variable
}
public static bool TryDivide(int a, int b, out int result)
{
if (b == 0)
{
result = 0; // out must be assigned before return
return false;
}
result = a / b;
return true;
}
}
public class Program
{
public static void Main(string[] args)
{
int n = 10;
RefOutDemo.Increment(ref n);
Console.WriteLine("n = " + n); // 11
int r;
bool ok = RefOutDemo.TryDivide(9, 0, out r);
Console.WriteLine("ok=" + ok + " r=" + r);
}
}
Sobrecarga e observação
Sobrecarga reutiliza um nome para operações relacionadas. Observação: funções locais aparecem em versões posteriores do C#; no C# 6, use pequenos auxiliares privados.
using System;
public static class Calc
{
// Overloads: same name, different parameter lists
public static int Area(int side) { return side * side; }
public static int Area(int width, int height) { return width * height; }
// C# 6 has no local functions; use private helpers instead.
private static int DoubleIt(int x) { return x + x; }
public static int TwiceArea(int side)
{
int a = Area(side);
return DoubleIt(a);
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine("Area square 3 = " + Calc.Area(3));
Console.WriteLine("Area rect 3x4 = " + Calc.Area(3, 4));
Console.WriteLine("Twice area of 3 = " + Calc.TwiceArea(3));
}
}
Regra de ref versus out
Recapitulação
Recapitulação: defina assinaturas claras, valores de retorno e pequenos auxiliares com corpo de expressão; use parâmetros opcionais e nomeados para melhorar a legibilidade; entenda ref versus out; faça sobrecargas com cuidado. As funções locais surgiram em versões posteriores do C#: use auxiliares privados no C# 6.
Perguntas Frequentes
A aula “Assinaturas e retornos; com corpo de expressão; opcionais/nomeados; ref/out; sobrecarga” é grátis?
Sim — o texto completo de “Assinaturas e retornos; com corpo de expressão; opcionais/nomeados; ref/out; sobrecarga” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 3 aulas no total.
O que vou aprender em “Assinaturas e retornos; com corpo de expressão; opcionais/nomeados; ref/out; sobrecarga”?
Defina assinaturas de métodos e valores de retorno, use métodos com corpo de expressão e parâmetros opcionais/nomeados e entenda ref/out e a sobrecarga. Observação: não há funções locais no C# 6. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C# Academy?
Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.
Quanto tempo leva a aula “Assinaturas e retornos; com corpo de expressão; opcionais/nomeados; ref/out; sobrecarga”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C# Academy?
Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Assinaturas e retornos; com corpo de expressão; opcionais/nomeados; ref/out; sobrecarga
- Parâmetros opcionais/nomeados; ref/out/in (noções básicas)
- Funções locais (observação sobre C# 6) e sobrecarga