Pojmenované a volitelné argumenty (Příručka programování C#)
Visual C# 2010Seznamuje s názvem a volitelné argumenty.Pojmenované argumenty umožňují zadat argument pro konkrétní parametr přiřazením argument název parametru, nikoli s umístěním na parametr v seznamu parametrů.Volitelné argumenty umožňují vynechat argumenty pro některé parametry.Obě tyto metody lze použít metody, indexování, konstruktory a delegáty.
Při použití pojmenovaných a volitelné argumenty argumenty jsou vyhodnocovány v pořadí, v jakém jsou uvedeny v seznamu argumentů, seznam parametrů.
Pojmenované a volitelné parametry při použití, umožňují zadat argumenty pouze několik parametrů ze seznamu volitelných parametrů.Tato funkce výrazně usnadňuje volání rozhraní COM, jako je například Microsoft Office Automation API.
Pojmenované argumenty
Pojmenované argumenty bez je třeba pamatovat nebo vyhledat pořadí parametrů v seznamech parametr volané metody.Název parametru je určen parametr pro každý argument.Například funkce, která vypočítá aplikace subjekt hmotnostní index (BMI) lze volat standardním způsobem odesláním argumenty pro hmotnost a výška podle umístění v pořadí definovaných funkcí.
CalculateBMI(123, 64);
Pokud si nepamatujete pořadí parametrů, ale neznáte jejich jména, můžete odeslat argumenty buď aby, nejprve hmotnost první nebo výška.
CalculateBMI(weight: 123, height: 64);
CalculateBMI(height: 64, weight: 123);
Pojmenované argumenty také zvýšit čitelnost kódu identifikující představuje každý argument.
Pojmenovaný argument podle argumentů umístění, jak je znázorněno zde.
CalculateBMI(123, height: 64);
Poziční argument však nelze podle pojmenovaný argument.Následující příkaz způsobí chybu kompilátoru.
//CalculateBMI(weight: 123, 64);
Příklad
Následující kód implementuje příklady z tohoto oddílu.
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);
}
}
Volitelné argumenty
Definice metody, konstruktor, indexer nebo delegáta můžete určit, že jeho parametry jsou požadovány nebo jsou volitelné.Každé volání musí poskytnout argumenty pro všechny požadované parametry, ale argumenty pro volitelné parametry, můžete vynechat.
Každý volitelný parametr má výchozí hodnotu jako součást jeho definice.Pokud u parametru je odeslán žádný argument, je použita výchozí hodnota.Výchozí hodnota musí být jeden z následujících typů výrazů:
konstantní výraz;
výraz formuláře new ValType(), kde ValType je typ hodnoty, například výčtu nebo struct;
výraz formuláře default(ValType), kde ValType je typ hodnoty.
Volitelné parametry jsou definovány na konci seznamu parametrů po všechny požadované parametry.Pokud volající poskytuje argument pro všechny po sobě volitelné parametry, poskytne argumenty pro všechny předchozí volitelné parametry.Mezery v seznamu argumentů oddělených čárkami nejsou podporovány.Například následující kód metoda instance ExampleMethod je definován je vyžadován a dva volitelné parametry.
public void ExampleMethod(int required, string optionalstr = "default string",
int optionalint = 10)
Následující volání na ExampleMethod způsobí chybu kompilátoru, protože poskytuje pro třetí parametr, ale ne pro druhý argument.
//anExample.ExampleMethod(3, ,4);
Avšak pokud znáte název třetí parametr, můžete pojmenovaný argument k provedení úkolu.
anExample.ExampleMethod(3, optionalint: 4);
Technologie IntelliSense pomocí závorky označují volitelné parametry, jak je znázorněno na následujícím obrázku.
Volitelné parametry v ExampleMethod
.png "Rychlé informace technologie IntelliSense pro metodu ExampleMethod.")
[!POZNÁMKA]
Volitelné parametry můžete také deklarovat pomocí.NET OptionalAttribute třídy.OptionalAttributeParametry nevyžadují výchozí hodnotu.
Příklad
V následujícím příkladu konstruktor pro ExampleClass má jeden parametr, který je volitelný.Metoda instance ExampleMethod má jeden povinný parametr requireda dva volitelné parametry, optionalstr a optionalint.Kód v Main zobrazí různými způsoby, ve kterém lze vyvolat konstruktor a metody.
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.
}
Rozhraní COM
Pojmenované a volitelné argumenty spolu s podporou dynamické objekty a další rozšíření značně zlepšit interoperabilitu s například Office Automation API rozhraní COM API.
Například Automatický formát metoda aplikace Microsoft Office Excel oblast rozhraní má sedm parametry, které jsou volitelné.Tyto parametry jsou zobrazeny na následujícím obrázku.
Parametry automatický formát
.png "Rychlé informace technologie IntelliSense pro metodu AutoFormat")
C# 3.0 a dřívější verze argument je vyžadován pro každý parametr, jak ukazuje následující příklad.
// 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);
Však výrazně usnadňuje volání AutoFormat pomocí pojmenovaných a volitelné argumenty v C# 4.0.Název a volitelné argumenty umožňují vynecháte argument pro volitelný parametr, pokud chcete změnit výchozí hodnoty.Následující volání je zadána hodnota pouze pro jeden z parametrů sedm.
// 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 );
Další informace a příklady viz Jak: použití pojmenovaných a volitelné argumenty v Office programování (Příručka programování C#) a Jak: Office Access Interop objektů pomocí aplikace Visual C# 2010 funkcí (C# Příručka programování).
Rozlišení přetěžování
Použití pojmenovaných a volitelné argumenty ovlivňuje řešení přetížení následujícími způsoby:
Metoda, indexer nebo konstruktoru je kandidáta pro spuštění, pokud každý z jeho parametry je volitelné nebo odpovídá podle názvu nebo podle pozice pro jeden argument v příkazu volajícího a že argument lze převést na typ parametru.
Pokud je nalezen více než jeden kandidát, přetížení rozlišení pro upřednostňované převody pravidly se argumenty, které jsou výslovně určeny.Vynechaných argumentů pro volitelné parametry jsou ignorovány.
Pokud jsou za dva kandidáty být stejně dobrý, předvoleb přejde na kandidáta, který nemá volitelné parametry, které byly vynechány argumenty ve volání.To je důsledek Obecné předvolby v řešení přetížení pro kandidáty, které mají menší počet parametrů.
Specifikace jazyka C#
Další informace naleznete v tématu Specifikace jazyka C#. Specifikace jazyka je úplným a rozhodujícím zdrojem pro syntaxi a použití jazyka C#.
Viz také
Úkoly
Jak: použití pojmenovaných a volitelné argumenty v Office programování (Příručka programování C#)
Referenční dokumentace
Pomocí konstruktorů (Příručka programování C#)
Pomocí indexování (Příručka programování C#)