Params em C#

Em C#, o modificador params permite que um método receba um número variável de argumentos de um mesmo tipo. Isso é útil quando você não sabe, no momento da definição do método, quantos argumentos serão passados. Ele oferece flexibilidade ao permitir que os parâmetros sejam passados como uma lista separada por vírgulas ou como um array. Neste post, aprenda tudo sobre params em c#.

Sintaxe básica

public void ExibirNumeros(params int[] numeros)
{
    foreach (int numero in numeros)
    {
        Console.WriteLine(numero);
    }
}

Neste exemplo, o método ExibirNumeros pode aceitar qualquer número de inteiros, incluindo nenhum. Internamente, o parâmetro numeros será tratado como um array de inteiros (int[]).

Usando params em Métodos

O modificador params é útil quando você deseja fornecer flexibilidade aos usuários de seu método, permitindo que eles passem um número variado de argumentos.

Exemplo simples

Vamos criar um exemplo onde usamos o params para somar uma lista de números, independentemente de quantos forem fornecidos:

public class ExemploParams
{
    public static void SomarNumeros(params int[] numeros)
    {
        int soma = 0;
        foreach (int numero in numeros)
        {
            soma += numero;
        }
        Console.WriteLine("Soma: " + soma);
    }

    static void Main()
    {
        SomarNumeros(1, 2, 3);  // Saída: Soma: 6
        SomarNumeros(10, 20);   // Saída: Soma: 30
        SomarNumeros();         // Saída: Soma: 0
    }
}

Neste exemplo, o método SomarNumeros pode ser chamado com um número variável de inteiros. Se nenhum valor for fornecido, o array será vazio e a soma será 0.

Regras e restrições do params

Embora o params seja muito flexível, ele tem algumas regras que devem ser seguidas:

Deve ser o último parâmetro: O parâmetro marcado com params deve ser o último da lista de parâmetros. Se houver outros parâmetros, eles devem vir antes do params.

public void ExibirDetalhes(string titulo, params string[] detalhes)
{
    Console.WriteLine(titulo);
    foreach (string detalhe in detalhes)
    {
        Console.WriteLine(detalhe);
    }
}

Somente um params por método: Um método pode ter apenas um parâmetro com o modificador params.

Pode ser omitido: Quando o método é chamado, o argumento correspondente ao params pode ser omitido, resultando em um array vazio dentro do método.

ExibirDetalhes("Título");  // Nenhum detalhe será exibido

Aceita arrays diretamente: Você pode passar um array diretamente para o parâmetro params, além de fornecer uma lista de argumentos separada por vírgulas.

int[] numeros = { 1, 2, 3, 4 };
SomarNumeros(numeros);  // Saída: Soma: 10

Exemplo: usando params com diferentes tipos

O params pode ser usado com qualquer tipo de dados, desde que você defina o tipo corretamente. Aqui está um exemplo com strings:

public void ExibirNomes(params string[] nomes)
{
    foreach (string nome in nomes)
    {
        Console.WriteLine("Nome: " + nome);
    }
}

Exemplo de uso

ExibirNomes("Alice", "Bob", "Carlos");
// Saída:
// Nome: Alice
// Nome: Bob
// Nome: Carlos

Vantagens do params

1. Flexibilidade: O params elimina a necessidade de sobrecarregar métodos para diferentes números de parâmetros, tornando o código mais enxuto e flexível;
   
   
2. Legibilidade: Em vez de exigir que os usuários criem arrays manualmente ao chamar o método, o params permite que eles passem argumentos diretamente, resultando em chamadas de método mais claras e concisas.

Sem params:

SomarNumeros(new int[] { 1, 2, 3 });

Com params:

SomarNumeros(1, 2, 3);

Outro exemplo

No exemplo abaixo criamos uma sobrecarga de método sem utilizar params:

class Calculadora {
	
   public static int Soma(int n1, int n2) {
        	
      return n1 + n2;
   }

   public static int Soma(int n1, int n2, int n3) {
        	
      return n1 + n2 + n3;
   }

   public static int Soma(int n1, int n2, int n3, int n4) {
        	
      return n1 + n2 + n3 + n4;
   }
 } 
     
...
     
//Mostra os resultados das somas
int s1 = Calculadora.Soma(1, 2);
int s2 = Calculadora.Soma(1, 2, 6);
int s3 = Calculadora.Soma(1, 2, 5, 10);
     
Console.Writeln(s1);
Console.Writeln(s2);
Console.Writeln(s3); 

Nas sobrecargas acima, o desafio é atender necessidades de mais números para a operação.

Uma forma mais fácil e elegante de resolver o problema acima é criar um método, usar a palavra-chave params e receber um vetor de números:

class Calculadora {
	
   public static int Soma(params int[] numeros) {
        	
     int soma = 0;
            
     for(int=0; i < numeros.Lenght; i++) {
            		
        soma += numeros[i];
     }
                    
        return soma;
  }
}   
    
    ...
    
    Mostra os resultados das somas
    int s1 = Calculadora.Soma(1, 2);
    int s2 = Calculadora.Soma(1, 2, 6);
    int s3 = Calculadora.Soma(1, 2, 5, 10);
    
    Console.Writeln(s1);
    Console.Writeln(s2);
    Console.Writeln(s3);

Desta forma será possível receber quantos números forem necessários sem precisar fazer mais sobrecargas do método.

O modificador params em C# é uma ferramenta útil para criar métodos que podem aceitar um número variável de argumentos, oferecendo flexibilidade e tornando o código mais fácil de manter e entender.

Ele é especialmente útil em cenários onde o número de entradas pode variar, como somatórios, concatenação de strings e outras operações que envolvem múltiplos argumentos.

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

Tags: params