C# - Parâmetros nomeados

C# - Argumentos nomeados

Neste artigo eu vou falar de um recurso introduzido na versão 4.0 do C#, os argumentos nomeados.

Já falamos de parâmetros opcionais neste artigo. Vamos continuar tratando de argumentos opcionais.

Para começar vamos definir o que é um parâmetro e o que é um argumento.

Os termos parâmetros e argumentos são frequentemente usados de forma intercambiáveis, embora eles tenham significados inteiramente diferentes.

Um parâmetro representa um valor que o procedimento espera receber quando for chamado. A declaração do procedimento define os seus parâmetros;
Um argumento representa o valor que você passa para um parâmetro de procedimento quando você chama o procedimento. O código de chamada fornece os argumentos quando ele chama o procedimento;

No meu artigo - C# - Parâmetros Opcionais - eu tratei dos parâmetros opcionais. Você deve ler este artigo para complementar o entendimento sobre parâmetros opcionais e argumentos nomeados pois eles se complementam.

Quando criamos um método na linguagem C# por padrão a chamada do método deve passar os argumentos respeitando o posicionamento dos parâmetros na lista de parâmetros definidos no método.

Assim para a classe Email o método Enviar() define três parâmetros : destino, titulo e assunto.

public Class Email
{
     public static void Enviar(string destino, string titulo, string assunto )
     {
           Console.WriteLine("{0},{1},{2}", destino, titulo, assunto);
    }
}

Para chamar o método Enviar passando os argumentos devemos respeitar a ordem dos parâmetros definidos na lista de parâmetros:

Email.Enviar("macoratti@yahoo.com", "Contato", "Gentileza entrar em contato para definir orçamento")

Se não seguirmos essa regra teremos problemas na execução do método com valores trocados ou erro de tipos de dados definidos incorretamente.

Com a introdução dos argumentos nomeados a partir do C# 4.0 podemos especificar um argumento para um determinado parâmetro associando o argumento com o nome do parâmetro, ao invés da posição do parâmetro na lista de parâmetros.

Dessa forma, usando argumentos nomeados, podemos chamar o método Enviar() assim :

Enviar(destino: "macoratti@yahoo.com", assunto: "Entrar em contato urgente", titulo: "Urgente");

Enviar(assunto: "Enviar o rascunho do projeto", titulo: "Enviar rascunho", destino: "macoratti@ig.com.br");

Enviar(titulo: "Ligar urgente", destino: "macoratti@yahoo.com", assunto: "Ligar para o diretor");

Note que estamos nomeando os argumentos identificando-os com os parâmetros definidos e dessa forma podemos usá-los em qualquer ordem na chamada do método visto que eles estão identificados pelo nome.

O método será chamado e executado de forma correta :

using System;

namespace Parametros_Opcionais
{
    class Program
    {
        static void Main(string[] args)
        {

          Enviar(destino: "macoratti@yahoo.com", assunto: "Entrar emcontato urgente", titulo: "Urgente");
            Enviar(assunto: "Enviar o rascunho do projeto", titulo: "Enviar rascunho", destino: "macoratti@ig.com.br");
            Enviar(titulo: "Ligar urgente", destino: "macoratti@yahoo.com", assunto: "Ligar para o diretor");
            Console.ReadKey();
        }

      public static void Enviar(string destino, string titulo, string assunto)
        {
            Console.WriteLine("{0},{1},{2}", destino, titulo, assunto);
        }
    }
}

Ao usar os argumentos nomeados não temos a necessidade de memorizar ou consultar a ordem dos parâmetros nas listas de parâmetro dos métodos chamados, pois o parâmetro para cada argumento pode ser especificado pelo seu nome.

Assim, se você não lembra a ordem dos parâmetros, mas você sabe que seus nomes, você pode enviar os argumentos em qualquer ordem, como mostra o exemplo acima.

Usando o recurso dos parâmetros opcionais e dos argumentos nomeados podemos flexibilizar ainda mais a chamada dos métodos.

Sabemos que qualquer chamada deve fornecer argumentos para todos os parâmetros necessários, mas podemos omitir argumentos para os parâmetros opcionais.

Cada parâmetro opcional tem um valor padrão como parte de sua definição (veja o artigo).

Se nenhum argumento for enviado para esse parâmetro, o valor padrão é usado. Um valor padrão deve ser um dos seguintes tipos de expressões:

uma expressão de constante;
uma expressão do formulário new ValType(), onde ValType é um tipo de valor, como um enum ou um struct;
uma expressão do formulário default(ValType), onde ValType é um tipo de valor.

Assim para um método CalculoImposto() definido a seguir com dois parâmetros opcionais :

public static void CalculoImposto(double valor, double taxa = .25, double desconto = 10.00 )
{
        Console.WriteLine (valor * taxa - desconto);
}

O método CalculoImposto() pode ser chamado das seguintes formas:

CalculoImposto(100, .35, 20.00); //chamada normal definindo o valor dos 3 parâmetros
CalculoImposto(100); //omitindo o valor dos argumentos para os parâmetros taxa e desconto
CalculoImposto(taxa: .45, valor: 200); //trocando a posição dos argumentos taxa e valor e omitindo o desconto
CalculoImposto(300, desconto: 25); //omitindo o argumento para taxa e definindo o desconto como 25

Note que os argumentos nomeados podem ser especificados em qualquer ordem.

A execução ocorrerá sem problemas como podemos ver :

Dessa forma, os argumentos nomeados e os parâmetros opcionais, quando usados em conjunto, permitem que você forneça argumentos para apenas alguns parâmetros de uma lista de parâmetros opcionais.

Esse recurso facilita bastante a chamadas para interfaces COM, como as APIs de automação de Microsoft Office.

E, estando ele em Jerusalém pela páscoa, durante a festa, muitos, vendo os sinais que fazia, creram no seu nome.
Mas o mesmo Jesus não confiava neles, porque a todos conhecia;
E não necessitava de que alguém testificasse do homem, porque ele bem sabia o que havia no homem.
João 2:23-25

Referências:

José Carlos Macoratti