Métodos em C#

No C#, os métodos são blocos de código que realizam tarefas específicas e podem ser reutilizados ao longo do programa. Eles são fundamentais para organizar, modularizar e simplificar o código, tornando-o mais legível e fácil de manter. Neste post, você aprenderá o que são métodos em C#, como criá-los, as diferentes formas de utilizá-los, e boas práticas ao implementá-los.

O que é um Método?

Um método é uma função definida dentro de uma classe que contém uma série de instruções para realizar uma ação específica. Ele pode ou não retornar valores e pode aceitar parâmetros como entrada. O uso de métodos ajuda a evitar repetição de código e facilita o desenvolvimento de funcionalidades complexas de forma organizada.

Estrutura básica de um Método

A sintaxe de um método em C# geralmente segue o seguinte formato:

[Modificadores] TipoDeRetorno NomeDoMetodo([Parâmetros])
{
    // Corpo do método
}

• Modificadores: Controlam a visibilidade e o comportamento do método (ex: public, private, static, etc.);
  
  
• TipoDeRetorno: Especifica o tipo de dado que o método retorna. Se o método não retornar um valor, usa-se void;
  
  
• NomeDoMetodo: O nome do método, que segue as convenções de nomenclatura (geralmente com a primeira letra maiúscula);
  
  
• Parâmetros: São as entradas que o método pode aceitar. Eles são opcionais e podem ser múltiplos ou nenhum.

Exemplo de um Método simples

Exemplo básico de um método que não retorna nenhum valor (ou seja, seu tipo de retorno é void) e apenas imprime uma mensagem:

public void Saudacao()
{
    Console.WriteLine("Olá, bem-vindo ao meu programa!");
}

Neste exemplo:

• public é o modificador de acesso, o que significa que o método pode ser acessado de qualquer parte do programa.
  
• void indica que o método não retorna um valor.
  
• Saudacao() é o nome do método.
  
• O corpo do método contém a instrução Console.WriteLine, que imprime a saudação no console.

Chamando um Método

Para chamar um método, você simplesmente usa o nome do método seguido de parênteses. Se o método estiver na mesma classe em que está sendo chamado, basta invocá-lo diretamente:

Saudacao();

Se o método estiver em uma instância de uma classe, você o chama através dessa instância:

MinhaClasse obj = new MinhaClasse();
obj.Saudacao();

Métodos com retorno

Métodos que retornam valores precisam especificar um tipo de retorno diferente de void. O valor de retorno pode ser qualquer tipo de dado, como int, string, bool, ou até mesmo classes e structs personalizados.

Exemplo de Método com retorno

Veja um exemplo de um método que soma dois números e retorna o resultado:

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

Nesse exemplo:

• O método Somar tem um tipo de retorno int, indicando que ele retornará um número inteiro.
  
• Ele recebe dois parâmetros, a e b, que também são inteiros.
  
• A palavra-chave return é usada para retornar o resultado da soma de a e b.

Chamando Métodos com retorno

Quando um método retorna um valor, você pode armazenar esse valor em uma variável ou utilizá-lo diretamente em expressões:

int resultado = Somar(5, 3);
Console.WriteLine("O resultado é: " + resultado);

Métodos com parâmetros

Os métodos podem aceitar parâmetros para processar dados. Esses parâmetros são declarados dentro dos parênteses na assinatura do método e são utilizados dentro do corpo do método.

Exemplo com parâmetros

Veja um exemplo de um método que recebe um nome como parâmetro e imprime uma saudação personalizada:

public void SaudacaoPersonalizada(string nome)
{
    Console.WriteLine("Olá, " + nome + ", seja bem-vindo!");
}

Neste caso, o método SaudacaoPersonalizada recebe uma string como parâmetro e utiliza esse valor para exibir uma mensagem personalizada.

Chamando Métodos com parâmetros

Ao chamar um método com parâmetros, você deve fornecer os valores correspondentes:

SaudacaoPersonalizada("Ana");

Sobrecarga de Métodos (Method Overloading)

A sobrecarga de métodos permite que você tenha múltiplos métodos com o mesmo nome, desde que eles tenham diferentes listas de parâmetros. Isso é útil quando você precisa que um método lide com diferentes tipos ou quantidades de dados.

Exemplo de sobrecarga

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;
}

Neste exemplo, o método Somar foi sobrecarregado três vezes:

• Um método soma dois inteiros.
• Outro soma dois valores double.
• Um terceiro soma três inteiros.

O compilador escolhe qual versão do método chamar com base nos tipos e quantidade de argumentos passados na chamada:

int resultado1 = Somar(2, 3);        // Chama a primeira versão (inteiros)
double resultado2 = Somar(2.5, 3.7); // Chama a segunda versão (double)
int resultado3 = Somar(1, 2, 3);     // Chama a terceira versão (3 inteiros)

Métodos estáticos

Métodos estáticos pertencem à classe, e não a uma instância específica. Para chamá-los, não é necessário criar um objeto da classe; basta chamar o método diretamente a partir da classe.

Exemplo de Método estático

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

Para chamar o método estático Somar, usamos o nome da classe:

int resultado = Calculadora.Somar(10, 5);

Parâmetros opcionais e nomeados

No C#, você pode fornecer valores padrão para os parâmetros, permitindo que eles sejam opcionais ao chamar o método.

Exemplo de parâmetros opcionais

public void ImprimirMensagem(string mensagem = "Olá, mundo!")
{
    Console.WriteLine(mensagem);
}

Se você não fornecer um valor ao chamar ImprimirMensagem(), a mensagem padrão "Olá, mundo!" será exibida:

ImprimirMensagem(); // Saída: "Olá, mundo!"
ImprimirMensagem("Bem-vindo ao C#"); // Saída: "Bem-vindo ao C#"

Você também pode utilizar parâmetros nomeados para especificar explicitamente quais valores atribuir a quais parâmetros:

ImprimirMensagem(mensagem: "Mensagem personalizada");

Mais exemplo de passagem de argumentos

Argumentos são informações passadas a um método, quando este é chamado. Genericamente, a relação entre parâmetro e método é a seguinte:

public void Somar(int n1, int n2) {
	
   Console.WriteLine("n1: " + n1);
   n1 += 800;           
   Console.WriteLine("Novo valor de n1: " +n1);
 } 
    
 //ref: modificador de parâmetro por referência
 public void Somar2(ref int n1, ref int n2) {
	
   Console.WriteLine("n1: " + n1 + ", n2: " + n2);
   n1 += 600;            
   Console.WriteLine("Novo valor de n1: " + n1);
   n2 += 600;
   Console.WriteLine("Novo valor de n2: " + n2);
 }
    
 static void Main(string[] args) {
	
    int num1 = 100;
    int num2 = 200;
    Console.Clear();
    Console.WriteLine("num1 antes da chamada: " + num1);

   Metodos obj = new Metodos();
   obj.Somar(num1, num2); //chamada do método Somar (n1 + num1) - passagem por valor
   Console.WriteLine("num1 depois da chamada: " + num1);
   Console.WriteLine("num1 antes da chamada: " + num1 + ", num2 antes da chamada: " + num2);            
   obj.Somar2(ref num1, ref num2); //chama método Somar - passagem por referência

   //((num1 = 100) + (num1 = num1 + 600)) = 700
   Console.WriteLine("num1 depois da chamada: " + num1); 

   //((num2 = 200) + (num2 = num2 + 600)) = 800
   Console.WriteLine("num2 depois da chamada: " + num2); 
   Console.ReadLine();

Boas práticas ao criar Métodos

• Seja claro e conciso nos nomes: Os nomes dos métodos devem ser descritivos e indicar claramente o que o método faz. Prefira CalcularMedia() ao invés de algo genérico como Executar();
  
  
• Evite métodos muito longos: Métodos devem ser curtos e focados em uma única responsabilidade. Isso torna o código mais fácil de testar e manter;
  
  
• Use parâmetros com moderação: Muitos parâmetros podem tornar o método difícil de usar e manter. Considere agrupar dados em classes ou structs quando necessário;
  
  
• Modularize o código: Sempre que possível, divida a lógica em métodos menores e reutilizáveis, em vez de ter um único método fazendo várias coisas ao mesmo tempo.

Métodos são uma parte essencial de qualquer aplicação em C#, permitindo que você organize e modularize o código de forma eficiente. Compreender a sintaxe, o uso de parâmetros e as melhores práticas para criar métodos irá melhorar a legibilidade e manutenção do seu código.

Utilize os métodos para dividir grandes tarefas em partes menores, e aproveite os benefícios da reutilização de código e da clareza na estrutura do seu programa.

Dúvidas ou sugestões sobre métodos em C#? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: metodos