C#: Noções básicas sobre métodos

1. O que é um método

Um método é um bloco de código que executa uma tarefa específica. Encapsular lógica repetitiva em métodos melhora a reutilização e a legibilidade do código.

Em C#, os métodos devem ser definidos dentro de uma classe ou estrutura, ao contrário das funções independentes em C. Ao usar instruções de nível superior, é possível definir funções locais.

2. Definição e chamada de métodos

(1) Sintaxe

access_modifier return_type method_name(parameter_list)
{
    method_body
}

▶ Exemplo

using System;

class Program
{
    static void SayHello()
    {
        Console.WriteLine("Hello, World!");
    }

    static void Main()
    {
        SayHello();
        SayHello();
    }
}

Hello, World!
Hello, World!

3. Parâmetros e valores de retorno

(1) Métodos com parâmetros

Os parâmetros permitem que um método receba dados externos, possibilitando que ele processe diferentes entradas.

▶ Exemplo

using System;

class Program
{
    static void Greet(string name)
    {
        Console.WriteLine("Hello, " + name + "!");
    }

    static void Main()
    {
        Greet("Alice");
        Greet("Bob");
    }
}

Hello, Alice!
Hello, Bob!

(2) Métodos com valores de retorno

Os valores de retorno permitem que um método retorne os resultados dos cálculos ao chamador.

▶ Exemplo

using System;

class Program
{
    static int Add(int a, int b)
    {
        return a + b;
    }

    static void Main()
    {
        int result = Add(3, 5);
        Console.WriteLine("3 + 5 = " + result);
        Console.WriteLine("10 + 20 = " + Add(10, 20));
    }
}

3 + 5 = 8
10 + 20 = 30

4. Parâmetros formais e reais

5. A instrução return

A instrução return tem dois objetivos:

1. Retornar um resultado ao chamador
2. Sair imediatamente do método — o código subsequente não é executado

▶ Exemplo

using System;

class Program
{
    static string GetGrade(int score)
    {
        if (score >= 90)
            return "Excellent";
        if (score >= 60)
            return "Pass";
        return "Fail";
    }

    static int Max(int a, int b)
    {
        if (a > b)
            return a;
        else
            return b;
    }

    static void Main()
    {
        Console.WriteLine(GetGrade(95));
        Console.WriteLine(GetGrade(70));
        Console.WriteLine(GetGrade(45));
        Console.WriteLine("Larger: " + Max(12, 8));
    }
}

Excellent
Pass
Fail
Larger: 12

6. Métodos void

void indica que um método não possui valor de retorno. Os métodos void não exigem uma instrução return, mas é possível usar return; para encerrar a execução antecipadamente.

▶ Exemplo

using System;

class Program
{
    static void PrintLine(int length)
    {
        if (length <= 0)
            return;
        string line = new string('-', length);
        Console.WriteLine(line);
    }

    static void PrintInfo(string name, int age)
    {
        Console.WriteLine("Name: " + name);
        Console.WriteLine("Age: " + age);
    }

    static void Main()
    {
        PrintInfo("Alice", 18);
        PrintLine(20);
        PrintLine(-5);
    }
}

Name: Alice
Age: 18
--------------------

7. A pilha de chamadas de métodos

A pilha de chamadas é o mecanismo de gerenciamento de memória utilizado quando um programa executa métodos. Cada vez que um método é chamado, um quadro de pilha é inserido na pilha; quando o método retorna, o quadro é removido da pilha.

▶ Exemplo

using System;

class Program
{
    static int Square(int x)
    {
        return x * x;
    }

    static int SumOfSquares(int a, int b)
    {
        int sa = Square(a);
        int sb = Square(b);
        return sa + sb;
    }

    static void Main()
    {
        int result = SumOfSquares(3, 4);
        Console.WriteLine("Result: " + result);
    }
}

Result: 25

O processo de chamada é o seguinte:

1. Main() pushed onto stack
2.   SumOfSquares(3, 4) pushed onto stack
3.     Square(3) pushed → returns 9 → popped
4.     Square(4) pushed → returns 16 → popped
5.   SumOfSquares returns 25 → popped
6. Main → outputs 25 → popped

ℹ️ A pilha segue o princípio “último a entrar, primeiro a sair”. Quanto mais profunda for a aninhamento dos métodos, maior será o número de quadros da pilha. O espaço da pilha é limitado; a recursão excessiva pode causar um estouro de pilha.

8. Convenções de nomenclatura de métodos

A nomenclatura de métodos em C# utiliza PascalCase: a primeira letra de cada palavra é maiúscula, sem sublinhados.

▶ Exemplo

using System;

class Program
{
    static double CalculateArea(double radius)
    {
        return 3.14159 * radius * radius;
    }

    static bool IsValidAge(int age)
    {
        return age >= 0 && age <= 150;
    }

    static void PrintUserInfo(string name, int age)
    {
        Console.WriteLine(name + ", age " + age);
    }

    static void Main()
    {
        double area = CalculateArea(5.0);
        Console.WriteLine("Area: " + area);
        Console.WriteLine("Valid age: " + IsValidAge(25));
        PrintUserInfo("Alice", 25);
    }
}

Area: 78.53975
Valid age: True
Alice, age 25

✅ Os nomes dos métodos devem começar com um verbo ou uma locução verbal, como Get, Set, Calculate, Is, Print, etc.

9. Métodos com corpo de expressão

O C# 6.0 introduziu métodos com corpo de expressão, utilizando => para simplificar as definições de métodos em uma única linha.

▶ Exemplo

using System;

class Program
{
    static int Square(int x) => x * x;

    static double CircleArea(double r) => 3.14159 * r * r;

    static bool IsAdult(int age) => age >= 18;

    static void Main()
    {
        Console.WriteLine(Square(7));
        Console.WriteLine(CircleArea(3.0));
        Console.WriteLine(IsAdult(20));
    }
}

49
28.27431
True

10. Passagem por valor

O C# utiliza a passagem por valor por padrão: os tipos de valor copiam os dados, enquanto os tipos de referência copiam a referência.

▶ Exemplo

using System;

class Program
{
    static void TryChange(int x)
    {
        x = 999;
    }

    static void Main()
    {
        int num = 10;
        TryChange(num);
        Console.WriteLine("num = " + num);
    }
}

num = 10

11. Vários tipos de retorno

Os métodos podem retornar vários tipos: int, double, string, bool, etc.

▶ Exemplo

using System;

class Program
{
    static int GetLength(string text)
    {
        return text.Length;
    }

    static double GetAverage(int a, int b)
    {
        return (a + b) / 2.0;
    }

    static bool IsPositive(double value)
    {
        return value > 0;
    }

    static string BuildGreeting(string name)
    {
        return "Welcome, " + name + "!";
    }

    static void Main()
    {
        Console.WriteLine(GetLength("Hello"));
        Console.WriteLine(GetAverage(3, 4));
        Console.WriteLine(IsPositive(-2.5));
        Console.WriteLine(BuildGreeting("Alice"));
    }
}

5
3.5
False
Welcome, Alice!

❓ Perguntas Frequentes

P: Um método pode não ter parâmetros? R: Sim, basta deixar a lista de parâmetros vazia, por exemplo, static void SayHi().

P: Um método pode ter várias instruções de retorno? R: Sim, mas em métodos que não sejam do tipo void, cada caminho de execução deve retornar um valor.

P: Um método void pode usar a instrução return? R: Sim, use return; para sair antecipadamente, mas ele não pode retornar nenhum valor.

P: Os parâmetros formais e reais precisam ter o mesmo nome? R: Não, eles são variáveis independentes e podem ter nomes diferentes.

P: Um método em C# pode existir fora de uma classe? R: Não, os métodos em C# devem estar dentro de uma classe ou estrutura, mas as funções locais podem ser definidas em instruções de nível superior.

📖 Resumo

• Um método é composto por um modificador de acesso, um tipo de retorno, um nome de método e uma lista de parâmetros
• Os parâmetros formais são variáveis na definição; os parâmetros reais são valores passados no local da chamada
• return retorna um resultado e sai do método; os métodos void não têm valor de retorno
• A pilha de chamadas gerencia a memória de execução dos métodos, seguindo o princípio “último a entrar, primeiro a sair”
• A nomenclatura de métodos em C# segue as convenções de PascalCase
• Os métodos com corpo de expressão => simplificam as definições de métodos de uma única linha
• Passagem por valor por padrão: os tipos de valor copiam os dados; a modificação dos parâmetros formais não afeta os parâmetros reais

📝 Exercícios

1. Escreva um método static int Factorial(int n) que calcule o fatorial de n e retorne o resultado
2. Escreva um método static bool IsEven(int num) que verifique se um número inteiro é par, utilizando a sintaxe de corpo de expressão
3. Escreva um método static void PrintMultiplicationTable(int n) que exiba a tabuada de n (de 1×n a 9×n)
4. Escreva um método static string ClassifyScore(int score) que retorne “Excelente”, “Bom”, “Aprovado” ou “Reprovado” com base na pontuação
5. Escreva um método static double CalcBMI(double weight, double height) que calcule o IMC a partir do peso (kg) e da altura (m)

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós