Argomenti denominati e facoltativi (Guida per programmatori C#)
In Visual C# 2010 sono stati introdotti gli argomenti denominati e facoltativi. Gli argomenti denominati consentono di specificare un argomento per un particolare parametro associando l'argomento al nome del parametro anziché alla posizione del parametro nell'elenco di parametri. Gli argomenti facoltativi consentono di omettere gli argomenti per alcuni parametri. Entrambe le tecniche possono essere utilizzate con i metodi, gli indicizzatori, i costruttori e i delegati.
Quando si utilizzano gli argomenti denominati e facoltativi, gli argomenti vengono valutati nell'ordine nel quale vengono visualizzati nell'elenco di argomenti, non nell'elenco di parametri.
I parametri denominati e facoltativi, se utilizzati insieme, consentono di fornire gli argomenti solo per alcuni parametri da un elenco di parametri facoltativi. Questa funzionalità semplifica considerevolmente le chiamate alle interfacce COM, quali le API di automazione di Microsoft Office.
Argomenti denominati
Gli argomenti denominati evitano di dover ricordare o cercare l'ordine di parametri negli elenchi di parametri dei metodi chiamati. Il parametro per ogni argomento può essere specificato dal nome del parametro. Una funzione che calcola l'indice di massa corporea (BMI, Body Mass Index), ad esempio, può essere chiamata normalmente inviando gli argomenti relativi a peso e altezza in base alla posizione, nell'ordine definito dalla funzione.
CalculateBMI(123, 64);
Se non si ricorda l'ordine dei parametri, ma se ne conoscono i nomi, è possibile inviare gli argomenti in qualsiasi ordine, ovvero prima il peso o prima l'altezza.
CalculateBMI(weight: 123, height: 64);
CalculateBMI(height: 64, weight: 123);
Gli argomenti denominati agevolano inoltre la lettura del codice identificando che cosa rappresenta ogni argomento.
Un argomento denominato può seguire gli argomenti posizionali, come illustrato di seguito.
CalculateBMI(123, height: 64);
Un argomento posizionale non può, tuttavia, seguire un argomento denominato. L'istruzione seguente causa un errore di compilazione.
//CalculateBMI(weight: 123, 64);
Esempio
Nel codice seguente sono implementati gli esempi di questa sezione.
class NamedExample
{
static void Main(string[] args)
{
// The method can be called in the normal way, by using positional arguments.
Console.WriteLine(CalculateBMI(123, 64));
// Named arguments can be supplied for the parameters in either order.
Console.WriteLine(CalculateBMI(weight: 123, height: 64));
Console.WriteLine(CalculateBMI(height: 64, weight: 123));
// Positional arguments cannot follow named arguments.
// The following statement causes a compiler error.
//Console.WriteLine(CalculateBMI(weight: 123, 64));
// Named arguments can follow positional arguments.
Console.WriteLine(CalculateBMI(123, height: 64));
}
static int CalculateBMI(int weight, int height)
{
return (weight * 703) / (height * height);
}
}
Argomenti facoltativi
La definizione di un metodo, un costruttore, un indicizzatore o un delegato può specificare che i parametri sono obbligatori o facoltativi. Tutte le chiamate devono specificare gli argomenti per tutti i parametri obbligatori, ma possono omettere gli argomenti per i parametri facoltativi.
Ogni parametro facoltativo dispone di un valore predefinito come parte della definizione. Se per tale parametro non viene inviato alcun argomento, verrà utilizzato il valore predefinito. I valori predefiniti devono essere costanti.
I parametri facoltativi sono definiti alla fine dell'elenco di parametri, dopo eventuali parametri obbligatori. Se il chiamante specifica un argomento per un parametro di una successione di parametri facoltativi, deve specificare gli argomenti per tutti i parametri facoltativi precedenti. I gap delimitati da virgole nell'elenco di argomenti non sono supportati. Nel codice seguente, ad esempio, il metodo di istanza ExampleMethod viene definito con un parametro obbligatorio e due parametri facoltativi.
public void ExampleMethod(int required, string optionalstr = "default string",
int optionalint = 10)
La chiamata seguente a ExampleMethod genera un errore del compilatore, poiché viene fornito un argomento per il terzo parametro ma non per il secondo.
//anExample.ExampleMethod(3, ,4);
Se, tuttavia, si conosce il nome del terzo parametro, è possibile utilizzare un argomento denominato per eseguire l'attività.
anExample.ExampleMethod(3, optionalint: 4);
IntelliSense utilizza parentesi per indicare parametri facoltativi, come mostrato nell'immagine seguente.
Parametri facoltativi in ExampleMethod
.png "Informazioni rapide di IntelliSense per il metodo ExampleMethod.")
Nota
È inoltre possibile dichiarare i parametri facoltativi utilizzando la classe OptionalAttribute .NET. I parametri OptionalAttribute non richiedono un valore predefinito.
Esempio
Nell'esempio seguente, il costruttore per ExampleClass dispone di un parametro facoltativo. Il metodo di istanza ExampleMethod dispone di un parametro obbligatorio, required, e di due parametri facoltativi, optionalstr e optionalint. Il codice in Main illustra i diversi modi in cui è possibile richiamare il costruttore e il metodo.
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);
}
}
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.
}
Interfacce COM
Gli argomenti denominati e facoltativi, insieme al supporto per gli oggetti dinamici e ad altri miglioramenti, aumentano considerevolmente l'interoperabilità con le API COM, quali le API di automazione di Office.
Il metodo AutoFormat nell'interfaccia Range di Microsoft Office Excel presenta ad esempio sette parametri facoltativi. Questi parametri sono indicati nell'immagine seguente.
Parametri AutoFormat
.png "Informazioni rapide di IntelliSense per il metodo AutoFormat.")
In C# 3.0 e versioni precedenti è necessario un argomento per ogni parametro, come mostrato nell'esempio seguente.
// 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.xlRangeAutoFormatAccounting1;
excelApp.get_Range("A1", "B4").AutoFormat(myFormat, Type.Missing,
Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
È tuttavia possibile semplificare in modo sostanziale la chiamata a AutoFormat mediante argomenti denominati e facoltativi, introdotti in C# 4.0. Gli argomenti denominati e facoltativi consentono di omettere l'argomento per un parametro facoltativo se non si desidera modificare il valore predefinito del parametro. Nella chiamata seguente, viene specificato un valore per uno solo dei sette parametri.
// 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 );
Per ulteriori informazioni ed esempi, vedere Procedura: utilizzare argomenti denominati e facoltativi nella programmazione di Office (Guida per programmatori C#) e Procedura: accedere agli oggetti di interoperabilità di Office utilizzando le funzionalità di Visual C# 2010 (Guida per programmatori C#).
Risoluzione dell'overload
L'utilizzo di argomenti denominati e facoltativi influisce sulla risoluzione dell'overload nei modi seguenti:
Un metodo, un indicizzatore o un costruttore è un candidato per l'esecuzione se ogni parametro è facoltativo o corrisponde, per nome o per posizione, a un solo argomento nell'istruzione chiamante e tale argomento può essere convertito nel tipo del parametro.
Se è disponibile più di un candidato, agli argomenti specificati in modo esplicito vengono applicate le regole di risoluzione dell'overload per le conversioni preferite. Gli argomenti omessi per i parametri facoltativi vengono ignorati.
Se due candidati sono giudicati ugualmente validi, la preferenza va a un candidato che non dispone di parametri facoltativi per i quali sono stati omessi gli argomenti nella chiamata. Si tratta di una conseguenza di una preferenza generale nella risoluzione dell'overload per i candidati che dispongono di meno parametri.
Specifiche del linguaggio C#
Per ulteriori informazioni, vedere la Specifiche del linguaggio C#. La specifica del linguaggio è la fonte ufficiale per la sintassi e l'utilizzo di C#.
Vedere anche
Attività
Riferimenti
Utilizzo di costruttori (Guida per programmatori C#)
Utilizzo degli indicizzatori (Guida per programmatori C#)