C# 4.0 – Parâmetros opcionais e nomeados

Entre as várias novidades do C# 4.0 estão os parâmetros nomeados e opcionais, para entender melhor o funcionamento das duas funcionalidades vamos criar um método que faz um cálculo de salário com base na quantidade de dias trabalhados, valor da hora de trabalho, e quantidade de horas trabalhadas por dia.

Vamos imaginar que cada funcionário trabalha 8 horas por dia, ganhando R$ 15 por hora, mas não sei quantos dias determinado funcionário trabalhou, então meu método recebe a quantidade de dias por parâmetro.

   1: static int CalcularSalario(int diasDeTrabalho)

   2: {

   3:     var valorHora = 15;

   4:     var horasPorDia = 8;

   5:     return diasDeTrabalho * (horasPorDia * valorHora);

   6: }

Só que agora, para alguns funcionários eu também tenho que informar o custo da hora de trabalho do mesmo, então eu vou criar uma sobrecarga de operadores para esse método, agora o método também receberá o valor da hora do funcionário, nesse ponto já temos dois métodos com a mesma funcionalidade, porém em alguns casos o parâmetro hora pode mudar.

   1: static int CalcularSalario(int diasDeTrabalho, int valorHora)

   2: {

   3:     var horasPorDia = 8;

   4:     return diasDeTrabalho * (horasPorDia * valorHora);

   5: }

Para aumentar um pouco o nosso exemplo, agora eu tenho um terceiro tipo de funcionário que eu também preciso passar o valor da hora de trabalho do mesmo, então vou criar outra sobrecarga passando também o valor da hora.

   1: static int CalcularSalario(int diasDeTrabalho, int valorHora, int horasPorDia)

   2: {

   3:     return diasDeTrabalho * (horasPorDia * valorHora);

   4: }

Veja abaixo o código todo, com as 3 possibilidades de chamada.

   1: static void Main(string[] args)

   2: {

   3:     Console.WriteLine(CalcularSalario(20));

   4:     Console.WriteLine(CalcularSalario(20, 15));

   5:     Console.WriteLine(CalcularSalario(20, 15, 8));

   6: }

7:

   8: static int CalcularSalario(int diasDeTrabalho)

   9: {

  10:     var valorHora = 15;

  11:     var horasPorDia = 8;

  12:     return diasDeTrabalho * (horasPorDia * valorHora);

  13: }

14:

  15: static int CalcularSalario(int diasDeTrabalho, int valorHora)

  16: {

  17:     var horasPorDia = 8;

  18:     return diasDeTrabalho * (horasPorDia * valorHora);

  19: }

20:

  21: static int CalcularSalario(int diasDeTrabalho, int valorHora, int horasPorDia)

  22: {

  23:     return diasDeTrabalho * (horasPorDia * valorHora);

  24: }

Com o C# 4.0 temos um recurso chamado parâmetros opcionais, onde na construção do método podemos colocar um valor padrão para cada parâmetro do método. Então analisando o caso mostrado, eu sei que o padrão é.

Quantidade de dias = 20
Quantidade de horas = 8
Valor da hora = 15

Veja abaixo como fica o código reescrito.

   1: static int CalcularSalario(int diasDetrabalho = 20, int valorHora = 15,
int horasPorDia = 8)

   2: {

   3:     return diasDetrabalho * (horasPorDia * valorHora);

   4: }

Só é preciso adicionar = valor na frente de cada parâmetro, o valor deve seguir o tipo do parâmetro bool calcular = true; string nome = “Márcio”. Veja abaixo como o código foi reduzido.

   1: static void Main(string[] args)

   2: {

   3:     Console.WriteLine(CalcularSalario());

   4:     Console.WriteLine(CalcularSalario(20));

   5:     Console.WriteLine(CalcularSalario(20, 15));

   6:     Console.WriteLine(CalcularSalario(20, 15, 8));

   7: }

8:

   9: static int CalcularSalario(int diasDetrabalho = 20, int valorHora = 15, 
int horasPorDia = 8)

  10: {

  11:     return diasDetrabalho * (horasPorDia * valorHora);

  12: }

Analisando o código acima com as chamadas para o método o comportamento será.

CalcularSalario() -> Como não passei nenhum parâmetro, o método vai utilizar o valor padrão de cada parâmetro.
CalcularSalario(20) -> Nesse caso só o primeiro parâmetro ou seja diasDeTrabalho foi informado, então será utilizado o parâmetro informado e para os outros parâmetros o valor padrão.
CalcularSalario(20, 15) -> Nesse caso o primeiro e o segundo parâmetro foram informados, no caso diasDeTrabalho e valorHora, para esses dois parâmetros o valor utilizado será o passado, e para horasPorDia será utilizado o valor padrão.
CalcularSalario(20, 15, 8) -> No último caso, como passei os três parâmetros, nenhum valor padrão será utilizado, e sim os valores passados na chamada do método.

Agora para exemplificar recurso de parâmetros nomeados, imaginem que eu queira passar somente diasDeTrabalho e horasPorDia, eu poderia tentar fazer da seguinte forma.

   1: Console.WriteLine(CalcularSalario(20, , 8));

Vai acontecer um erro, dizendo que eu preciso especificar o parâmetro que está faltando, é aqui que vamos utilizar os parâmetros nomeados, vamos informar diretamente para o método qual parâmetro estamos preenchendo. Veja abaixo.

   1: Console.WriteLine(CalcularSalario(20, horasPorDia:8));

Dessa forma eu consigo “pular” um parâmetro e informo qual parâmetro deve receber o valor informado, a sintaxe é simples nomeDoParametro:valor.

Veja abaixo o código fonte completo do exemplo.

   1: static void Main(string[] args)

   2: {

   3:     Console.WriteLine(CalcularSalario());

   4:     Console.WriteLine(CalcularSalario(20));

   5:     Console.WriteLine(CalcularSalario(20, 15));

   6:     Console.WriteLine(CalcularSalario(20, 15, 8));

   7:     Console.WriteLine(CalcularSalario(20, horasPorDia:8));

   8: }

9:

  10: static int CalcularSalario(int diasDetrabalho = 20, int valorHora = 15,
int horasPorDia = 8)

  11: {

  12:     return diasDetrabalho * (horasPorDia * valorHora);

  13: }

Essa foi uma pequena demonstração do que encontraremos de novo no C# 4.0, em breve mais novidades.

Abraços.

Desenvolvimento - C#

Leia também