📽️

Antes de mergulharmos nas funções em C#, que tal dar uma olhada neste vídeo? Descubra 5 motivos essenciais para dominar métodos em C# que vão elevar suas habilidades de programação!

O que são métodos e por que usá-los?

Quer um exemplo? Se você precisa calcular a soma de números em várias partes do seu programa, em vez de repetir o código de soma em cada lugar, você cria um método Somar e o chama sempre que precisar somar números.

Sintaxe Básica de um Método em C#

public static int Somar(int a, int b)
{
    return a + b;
}

Componentes Principais de um Método em C#:

• Modificador de acesso: especifica quem pode acessar o método.
• public: o método pode ser acessado de qualquer lugar.
• private: o método só pode ser acessado dentro da classe em que foi declarado.
• protected: o método pode ser acessado dentro da classe e por classes derivadas.
• internal: o método pode ser acessado dentro do mesmo assembly.
• protected internal: combina as funcionalidades de protected e internal.
• private protected: disponível a partir do C# 7.2, restringe o acesso a dentro da classe ou tipos derivados no mesmo assembly.

Escolher o modificador de acesso adequado é importante para encapsular e proteger os dados e funcionalidades da sua classe.

• static: indica que o método pertence à classe e não a uma instância específica. Pode ser chamado diretamente pela classe.

• Tipo de Retorno: o tipo de dado que o método irá retornar. Se o método não retornar nada, usamos void.

• Nome do Método: deve ser descritivo e seguir as convenções de nomenclatura da linguagem.

• Parâmetros: dados de entrada que o método recebe para realizar suas operações.

• Corpo do Método: bloco de código que contém as instruções a serem executadas.

Exemplo Completo:

class Program
{
    static void Main(string[] args)
    {
        int resultado = Somar(5, 3);
        Console.WriteLine("Resultado: " + resultado);
    }

    public static int Somar(int a, int b)
    {
        return a + b;
    }
}

Quando você executa o código acima, o método Somar será chamado, somará os dois números e retornará o resultado.

Passagem de parâmetros

1. Passagem por valor

class Program
{
    static void DobrarValor(int x)
    {
        x = x * 2;
    }

    static void Main(string[] args)
    {
        int numero = 5;
        DobrarValor(numero);
        Console.WriteLine("Número após DobrarValor: " + numero); // Saída: 5
    }
}

Como o valor é passado por cópia, o valor original não é alterado.

2. Passagem por referência

class Program
{
    static void DobrarReferencia(ref int x)
    {
        x = x * 2;
    }

    static void Main(string[] args)
    {
        int numero = 5;
        DobrarReferencia(ref numero);
        Console.WriteLine("Número após DobrarReferencia: " + numero); // Saída: 10
    }
}

Aqui, o valor de numero é alterado diretamente dentro do método porque ele foi passado por referência.

3. Parâmetros de saída com out

class Program
{
    static void ObterValores(out int x, out int y)
    {
        x = 10;
        y = 20;
    }

    static void Main(string[] args)
    {
        int a, b;
        ObterValores(out a, out b);
        Console.WriteLine($"Valores obtidos: a = {a}, b = {b}"); // Saída: Valores obtidos: a = 10, b = 20
    }
}

Com out, os parâmetros devem ser inicializados dentro do método antes de serem usados.

• O parâmetro passado com ref deve ser inicializado antes de ser passado para o método.

• O parâmetro passado com out não precisa ser inicializado antes da chamada do método, mas deve ser atribuído dentro do método antes que ele termine.

Parâmetros somente leitura com in

class Program
{
    static void ExibirValor(in int x)
    {
        // x = x * 2; // Isso causaria um erro de compilação, pois x é somente leitura.
        Console.WriteLine($"Valor de x: {x}");
    }

    static void Main(string[] args)
    {
        int numero = 5;
        ExibirValor(numero);
    }
}

O uso de in é útil quando você está passando estruturas grandes por valor e deseja evitar a cópia, mas sem permitir modificações no valor original.

Retorno de valores: métodos com e sem retorno

Exemplo de um método com retorno:

class Calculadora
{
    public int Multiplicar(int a, int b)
    {
        return a * b;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Calculadora calc = new Calculadora();
        int produto = calc.Multiplicar(4, 5);
        Console.WriteLine("Produto: " + produto); // Saída: Produto: 20
    }
}

Exemplo de um método sem retorno (void):

class Mensagem
{
    public void ExibirMensagem()
    {
        Console.WriteLine("Olá, dev!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Mensagem msg = new Mensagem();
        msg.ExibirMensagem(); // Saída: Olá, dev!
    }
}

Use métodos com retorno quando precisar que o método devolva um resultado. Caso contrário, void é a melhor opção.

Funções anônimas e expressões lambda

Exemplo de uma função anônima usando lambda:

using System;

class Program
{
    static void Main(string[] args)
    {
        Func<int, int, int> somar = (a, b) => a + b;
        Console.WriteLine(somar(10, 20)); // Saída: 30
    }
}

Nesse exemplo, criamos uma função anônima que soma dois números e a atribuímos à variável somar. Essa sintaxe é muito comum quando estamos trabalhando com coleções e LINQ. LINQ? Não se preocupe, vou explicar logo abaixo.

Introdução ao LINQ

using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<int> numeros = new List<int> { 1, 2, 3, 4, 5 };
        var numerosPares = numeros.Where(n => n % 2 == 0);

        Console.WriteLine("Números pares:");
        foreach (var num in numerosPares)
        {
            Console.WriteLine(num);
        }
    }
}

No exemplo acima, usamos uma expressão lambda n => n % 2 == 0 dentro do método Where que filtra os números pares da lista.

Sobrecarga de métodos

Exemplo de sobrecarga:

class Calculadora
{
    public int Somar(int a, int b)
    {
        return a + b;
    }

    public double Somar(double a, double b)
    {
        return a + b;
    }

    public int Somar(int a, int b, int c)
    {
        return a + b + c;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Calculadora calc = new Calculadora();

        int resultadoInt = calc.Somar(5, 3);
        Console.WriteLine("Resultado (int): " + resultadoInt); // Saída: 8

        double resultadoDouble = calc.Somar(5.5, 3.2);
        Console.WriteLine("Resultado (double): " + resultadoDouble); // Saída: 8.7

        int resultadoTres = calc.Somar(1, 2, 3);
        Console.WriteLine("Resultado (três parâmetros): " + resultadoTres); // Saída: 6
    }
}

Aqui, temos três métodos Somar, cada um com diferentes tipos e números de parâmetros. Isso nos dá mais flexibilidade na hora de reutilizar métodos com diferentes entradas.

Classes, instâncias e o método Main no C#

Métodos de instância vs. métodos estáticos

• Métodos Estáticos: pertencem à classe em si e podem ser chamados sem criar um objeto. Usamos o modificador static na declaração.

• Métodos de Instância: pertencem a um objeto específico da classe. Para usá-los, precisamos criar uma instância (objeto) da classe.

Exemplo prático:

class Pessoa
{
    private string nome;
    private int idade;

    // Construtor da classe
    public Pessoa(string nome, int idade)
    {
        this.nome = nome;
        this.idade = idade;
    }

    // Método de instância
    public void Apresentar()
    {
        Console.WriteLine($"Olá, meu nome é {nome} e tenho {idade} anos.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Criando uma instância da classe Pessoa
        Pessoa pessoa1 = new Pessoa("Maria", 30);
        pessoa1.Apresentar();

        // Podemos criar várias instâncias com dados diferentes
        Pessoa pessoa2 = new Pessoa("João", 25);
        pessoa2.Apresentar();
    }
}

Neste exemplo, o método Apresentar é um método de instância, pois ele depende dos dados específicos de cada objeto Pessoa. Para chamá-lo, precisamos criar uma instância da classe usando new Pessoa(...).

Por que isso é importante?

Métodos recursivos

Exemplo de método recursivo:

class Program
{
    static int Fatorial(int n)
    {
        if (n < 0)
        {
            throw new ArgumentException("Não é possível calcular o fatorial de um número negativo.");
        }
        if (n == 0 || n == 1)
        {
            return 1;
        }
        return n * Fatorial(n - 1);
    }

    static void Main(string[] args)
    {
        int numero = 5;
        try
        {
            int resultado = Fatorial(numero);
            Console.WriteLine($"Fatorial de {numero} é {resultado}"); // Saída: Fatorial de 5 é 120
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

Explicação do código:

1. Condição de erro para números negativos: o método verifica se o número n é negativo e lança uma exceção ArgumentException se for. Isso impede o cálculo de fatoriais negativos, que não são definidos matematicamente.

2. Condição de parada: se n for 0 ou 1, o método retorna 1, pois o fatorial de 0 e 1 é 1. Essa é a condição de parada da recursão.

3. Chamada recursiva: para valores maiores que 1, o método se chama novamente com o valor n-1, acumulando o produto de n * (n-1) * (n-2) * ... * 1.

4. Tratamento de exceção: no método Main, o try-catch captura a exceção de números negativos e exibe a mensagem apropriada ao usuário.

Percebeu? O método Fatorial chama a si mesmo até atingir a condição base. Adicionamos uma verificação para números negativos, exibindo uma mensagem de erro quando aplicável.

Boas práticas ao criar métodos

1. Nomes claros e descritivos: escolha nomes que indiquem claramente o que o método faz.

2. Métodos com responsabilidade única: cada método deve fazer uma única coisa. Isso facilita a manutenção e o entendimento do código.

3. Documentação: use comentários para explicar o propósito do método, especialmente em métodos mais complexos.

4. Evite muitos parâmetros: se um método precisar de muitos parâmetros, talvez seja hora de repensar o design.

5. Consistência: mantenha um estilo consistente de codificação em todo o projeto.

Conclusão

• Como começar a aprender C#

• Estruturas condicionais em C#: Guia prático

• Entendendo variáveis e tipos primitivos em C#

• C# Arrays vs Lists: Quando usar?

E claro, continue praticando! A prática é a chave para dominar qualquer linguagem.