22/09/2019 Argumentos nomeados e opcionais – Guia de Programação em C# | Microsoft Docs

Argumentos nomeados e
opcionais (Guia de Programação
em C#)
19/07/2015 • 6 minutos para ler •
Neste artigo
Argumentos nomeados
Exemplo
Argumentos opcionais
Exemplo
Interfaces COM
Resolução de sobrecarga
Especificação da Linguagem C#
Consulte também

O C# 4 apresenta argumentos nomeados e opcionais. Argumentos nomeados permitem

especificar um argumento para um parâmetro específico associando o argumento ao
nome do parâmetro e não com à posição do parâmetro na lista de parâmetros.
Argumentos opcionais permitem omitir argumentos para alguns parâmetros. Ambas as
técnicas podem ser usadas com os métodos, indexadores, construtores e delegados.

Quando você usa argumentos nomeados e opcionais, os argumentos são avaliados na

ordem em que aparecem na lista de argumentos e não na lista de parâmetros.

Os parâmetros nomeados e opcionais, quando usados em conjunto, permitem que

você forneça argumentos para apenas alguns parâmetros de uma lista de parâmetros
opcionais. Essa capacidade facilita bastante a chamadas para interfaces COM como as
APIs de Automação do Microsoft Office.

Argumentos nomeados
Os argumentos nomeados liberam você da necessidade de lembrar ou procurar a
ordem dos parâmetros nas listas de parâmetros de métodos chamados. O parâmetro
para cada argumento pode ser especificado pelo nome do parâmetro. Por exemplo,
uma função que imprime detalhes de pedidos (como o nome do vendedor, nome do
produto e número do pedido) pode ser chamada da maneira padrão, por meio do
envio de argumentos por posição, na ordem definida pela função.
https://docs.microsoft.com/pt-br/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments 1/8
22/09/2019 Argumentos nomeados e opcionais – Guia de Programação em C# | Microsoft Docs

PrintOrderDetails("Gift Shop", 31, "Red Mug");

Se não se lembrar da ordem dos parâmetros, mas souber os nomes, você poderá enviar
os argumentos em qualquer ordem.

PrintOrderDetails(orderNum: 31, productName: "Red Mug", sellerName: "Gift Shop");

PrintOrderDetails(productName: "Red Mug", sellerName: "Gift Shop", orderNum: 31);

Os argumentos nomeados também melhoram a legibilidade do código identificando o

que cada argumento representa. No método de exemplo abaixo, o sellerName não
pode ser nulo ou um espaço em branco. Como sellerName e productName são tipos de
cadeia de caracteres, em vez de enviar argumentos por posição, é melhor usar
argumentos nomeados para remover a ambiguidade dos dois e reduzir a confusão para
qualquer pessoa que leia o código.

Os argumentos nomeados, quando usados com argumentos posicionais, são válidos,

desde que

não sejam seguidos por argumentos posicionais ou,

PrintOrderDetails("Gift Shop", 31, productName: "Red Mug");

começando com o C# 7.2, sejam usados na posição correta. No exemplo a seguir,

o parâmetro orderNum está na posição correta, mas não está explicitamente
nomeado.

PrintOrderDetails(sellerName: "Gift Shop", 31, productName: "Red Mug");

No entanto, argumentos nomeados fora de ordem serão inválidos se estiverem

seguidos por argumentos posicionais.

C# ＝ Copiar

// This generates CS1738: Named argument specifications must appear after

all fixed arguments have been specified.
PrintOrderDetails(productName: "Red Mug", 31, "Gift Shop");

Exemplo
O código a seguir implementa os exemplos desta seção, juntamente com outros
exemplos.

C# ＝ Copiar

https://docs.microsoft.com/pt-br/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments 2/8
22/09/2019 Argumentos nomeados e opcionais – Guia de Programação em C# | Microsoft Docs

class NamedExample
{
static void Main(string[] args)
{
// The method can be called in the normal way, by using positional
arguments.
PrintOrderDetails("Gift Shop", 31, "Red Mug");

// Named arguments can be supplied for the parameters in any order.

PrintOrderDetails(orderNum: 31, productName: "Red Mug", sellerName:
"Gift Shop");
PrintOrderDetails(productName: "Red Mug", sellerName: "Gift Shop",
orderNum: 31);

// Named arguments mixed with positional arguments are valid

// as long as they are used in their correct position.
PrintOrderDetails("Gift Shop", 31, productName: "Red Mug");
PrintOrderDetails(sellerName: "Gift Shop", 31, productName: "Red
Mug"); // C# 7.2 onwards
PrintOrderDetails("Gift Shop", orderNum: 31, "Red Mug");
// C# 7.2 onwards

// However, mixed arguments are invalid if used out-of-order.

// The following statements will cause a compiler error.
// PrintOrderDetails(productName: "Red Mug", 31, "Gift Shop");
// PrintOrderDetails(31, sellerName: "Gift Shop", "Red Mug");
// PrintOrderDetails(31, "Red Mug", sellerName: "Gift Shop");
}

static void PrintOrderDetails(string sellerName, int orderNum, string

productName)
{
if (string.IsNullOrWhiteSpace(sellerName))
{
throw new ArgumentException(message: "Seller name cannot be null
or empty.", paramName: nameof(sellerName));
}

Console.WriteLine($"Seller: {sellerName}, Order #: {orderNum},

Product: {productName}");
}
}

Argumentos opcionais
A definição de um método, construtor, indexador ou delegado pode especificar que
seus parâmetros são obrigatórios ou que são opcionais. Qualquer chamada deve
fornecer argumentos para todos os parâmetros necessários, mas pode omitir
argumentos para parâmetros opcionais.

https://docs.microsoft.com/pt-br/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments 3/8
22/09/2019 Argumentos nomeados e opcionais – Guia de Programação em C# | Microsoft Docs

Cada parâmetro opcional tem um valor padrão como parte de sua definição. Se
nenhum argumento é 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 da forma new ValType() , em que ValType é um tipo de valor,

como um enum ou um struct;

uma expressão da forma default(ValType), em que ValType é um tipo de valor.

Os parâmetros opcionais são definidos no final da lista de parâmetros, depois de todos

os parâmetros obrigatórios. Se o chamador fornecer um argumento para qualquer um
de uma sucessão de parâmetros opcionais, ele deverá fornecer argumentos para todos
os parâmetros opcionais anteriores. Não há suporte para intervalos separados por
vírgula na lista de argumentos. Por exemplo, no código a seguir, método de instância
ExampleMethod está definido com um parâmetro obrigatório e dois opcionais.

C# ＝ Copiar

public void ExampleMethod(int required, string optionalstr = "default

string",
int optionalint = 10)

A chamada para ExampleMethod a seguir causa um erro do compilador, porque um

argumento é fornecido para o terceiro parâmetro, mas não para o segundo.

//anExample.ExampleMethod(3, ,4);

No entanto, se você souber o nome do terceiro parâmetro, poderá usar um argumento

nomeado para realizar a tarefa.

anExample.ExampleMethod(3, optionalint: 4);

O IntelliSense usa colchetes para indicar parâmetros opcionais, conforme mostrado na

seguinte ilustração:

７ Observação

Você também pode declarar parâmetros opcionais usando a classe

OptionalAttribute do .NET. Os parâmetros OptionalAttribute não exigem um
https://docs.microsoft.com/pt-br/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments 4/8
22/09/2019 Argumentos nomeados e opcionais – Guia de Programação em C# | Microsoft Docs

valor padrão.

Exemplo
No exemplo a seguir, o construtor para ExampleClass tem um parâmetro, que é
opcional. O método de instância ExampleMethod tem um parâmetro obrigatório,
required e dois parâmetros opcionais, optionalstr e optionalint . O código em Main
mostra as diferentes maneiras como o construtor e o método podem ser invocados.

C# ＝ Copiar

namespace OptionalNamespace
{
class OptionalExample
{
static void Main(string[] args)
{
// Instance anExample does not send an argument for the
constructor's
// optional parameter.
ExampleClass anExample = new ExampleClass();
anExample.ExampleMethod(1, "One", 1);
anExample.ExampleMethod(2, "Two");
anExample.ExampleMethod(3);

// Instance anotherExample sends an argument for the

constructor's
// optional parameter.
ExampleClass anotherExample = new ExampleClass("Provided name");
anotherExample.ExampleMethod(1, "One", 1);
anotherExample.ExampleMethod(2, "Two");
anotherExample.ExampleMethod(3);

// The following statements produce compiler errors.

// An argument must be supplied for the first parameter, and it

// must be an integer.
//anExample.ExampleMethod("One", 1);
//anExample.ExampleMethod();

// You cannot leave a gap in the provided arguments.

//anExample.ExampleMethod(3, ,4);
//anExample.ExampleMethod(3, 4);

// You can use a named parameter to make the previous

// statement work.
anExample.ExampleMethod(3, optionalint: 4);
}
}

https://docs.microsoft.com/pt-br/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments 5/8
22/09/2019 Argumentos nomeados e opcionais – Guia de Programação em C# | Microsoft Docs

class ExampleClass
{
private string _name;

// Because the parameter for the constructor, name, has a default

// value assigned to it, it is optional.
public ExampleClass(string name = "Default name")
{
_name = name;
}

// The first parameter, required, has no default value assigned

// to it. Therefore, it is not optional. Both optionalstr and
// optionalint have default values assigned to them. They are
optional.
public void ExampleMethod(int required, string optionalstr =
"default string",
int optionalint = 10)
{
Console.WriteLine("{0}: {1}, {2}, and {3}.", _name, required,
optionalstr,
optionalint);
}
}

// The output from this example is the following:

// Default name: 1, One, and 1.
// Default name: 2, Two, and 10.
// Default name: 3, default string, and 10.
// Provided name: 1, One, and 1.
// Provided name: 2, Two, and 10.
// Provided name: 3, default string, and 10.
// Default name: 3, default string, and 4.

Interfaces COM
Os argumentos nomeados e opcionais, juntamente com suporte para objetos
dinâmicos e outros aprimoramentos, aprimoram enormemente a interoperabilidade
com APIs COM, como APIs de Automação do Office.

Por exemplo, o método AutoFormat na interface Range do Microsoft Office Excel tem
sete parâmetros, todos opcionais. Esses parâmetros são mostrados na seguinte
ilustração:

https://docs.microsoft.com/pt-br/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments 6/8
22/09/2019 Argumentos nomeados e opcionais – Guia de Programação em C# | Microsoft Docs

No C# 3.0 e versões anteriores, é necessário um argumento para cada parâmetro, como

mostrado no exemplo a seguir.

C# ＝ Copiar

// In C# 3.0 and earlier versions, you need to supply an argument for

// every parameter. The following call specifies a value for the first
// parameter, and sends a placeholder value for the other six. The
// default values are used for those parameters.
var excelApp = new Microsoft.Office.Interop.Excel.Application();
excelApp.Workbooks.Add();
excelApp.Visible = true;

var myFormat =

Microsoft.Office.Interop.Excel.XlRangeAutoFormat.xlRangeAutoFormatAccounting
1;

excelApp.get_Range("A1", "B4").AutoFormat(myFormat, Type.Missing,

Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);

No entanto, você pode simplificar muito a chamada para AutoFormat usando

argumentos nomeados e opcionais, introduzidos no C# 4.0. Os argumentos nomeados
e opcionais permitem que você omita o argumento para um parâmetro opcional se não
desejar alterar o valor padrão do parâmetro. Na chamada a seguir, um valor é
especificado para apenas um dos sete parâmetros.

C# ＝ Copiar

// The following code shows the same call to AutoFormat in C# 4.0. Only
// the argument for which you want to provide a specific value is listed.
excelApp.Range["A1", "B4"].AutoFormat( Format: myFormat );

Para obter mais informações e exemplos, confira Como usar argumentos nomeados e
opcionais na programação do Office e Como acessar objetos de interoperabilidade do
Office usando recursos do Visual C#.

Resolução de sobrecarga
O uso de argumentos nomeados e opcionais afeta a resolução de sobrecarga das
seguintes maneiras:

Um método, indexador ou construtor é um candidato para a execução se cada um

dos parâmetros é opcional ou corresponde, por nome ou posição, a um único
argumento na instrução de chamada e esse argumento pode ser convertido para
o tipo do parâmetro.
https://docs.microsoft.com/pt-br/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments 7/8
22/09/2019 Argumentos nomeados e opcionais – Guia de Programação em C# | Microsoft Docs

Se mais de um candidato for encontrado, as regras de resolução de sobrecarga de

conversões preferenciais serão aplicadas aos argumentos que são especificados
explicitamente. Os argumentos omitidos para parâmetros opcionais são
ignorados.

Se dois candidatos são considerados igualmente bons, a preferência vai para um

candidato que não tem parâmetros opcionais para os quais argumentos foram
omitidos na chamada. Esta é uma consequência da preferência geral na resolução
de sobrecarga de candidatos que têm menos parâmetros.

Especificação da Linguagem C#
Para obter mais informações, consulte a Especificação da linguagem C#. A especificação
da linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Consulte também
Como: usar argumentos nomeados e opcionais na programação do Office
Usando o tipo dynamic
Usando construtores
Usando indexadores

Esta página é útil?

 Sim  Não

https://docs.microsoft.com/pt-br/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments 8/8