Angeben benannter und optionaler Methodenargumente
Mit benannten Argumenten können Sie ein Argument für einen Parameter angeben, indem Sie das Argument mit seinem Namen und nicht mit der Position in der Parameterliste abgleichen. Mit optionalen Argumenten können Sie Argumente für einige Parameter weglassen. Beide Techniken können mit Methoden, Indexern, Konstruktoren und Delegaten verwendet werden.
Wenn Sie benannte und optionale Argumente verwenden, werden die Argumente in der Reihenfolge ausgewertet, in der sie in der Argumentliste und nicht in der Parameterliste angezeigt werden.
Mit benannten und optionalen Parametern können Sie Argumente für ausgewählte Parameter angeben. Mit dieser Funktion werden Aufrufe an COM-Schnittstellen wie die Microsoft Office-Automatisierungs-APIs erheblich vereinfacht.
Benannte Argumente
Benannte Argumente befreien Sie vom Abgleichen der Reihenfolge der Argumente zur Reihenfolge der Parameter in den Parameterlisten der aufgerufenen Methoden. Das Argument für jeden Parameter kann durch den Parameternamen angegeben werden.
Anmerkung
Benannte Argumente verbessern die Lesbarkeit des Codes, indem ermittelt wird, was jedes Argument darstellt.
Berücksichtigen Sie eine Methode, die die folgende Methodensignatur verwendet:
static void PrintOrderDetails(string sellerName, int orderNum, string productName)
{
// Code to print the order details
}
Diese Methode kann erfolgreich aufgerufen werden, ohne benannte Argumente zu verwenden, solange sich die Argumente in der richtigen Reihenfolge befinden (definiert durch die Methodensignatur):
PrintOrderDetails("Gift Shop", 31, "Red Mug");
Wenn Sie sich nicht an die Reihenfolge der Parameter erinnern, aber deren Namen kennen, können Sie die Argumente in beliebiger Reihenfolge senden.
PrintOrderDetails(orderNum: 31, productName: "Red Mug", sellerName: "Gift Shop");
PrintOrderDetails(productName: "Red Mug", sellerName: "Gift Shop", orderNum: 31);
Bei Verwendung mit Positionsargumenten sind benannte Argumente gültig, solange sie an der richtigen Position verwendet werden.
Das folgende Beispiel funktioniert ordnungsgemäß, da der Parameter productName explizit benannt ist, keine Positionsargumente gefolgt ist und sich an der richtigen Position befindet.
PrintOrderDetails("Gift Shop", 31, productName: "Red Mug");
Positionsargumente, die auf nicht sortierte benannte Argumente folgen, sind ungültig.
// This generates CS1738: Named argument specifications must appear after all fixed arguments have been specified.
PrintOrderDetails(productName: "Red Mug", 31, "Gift Shop");
Optionale Argumente
Eine Methodendefinition kann angeben, ob die Parameter erforderlich oder optional sind. Jeder Aufruf muss Argumente für alle erforderlichen Parameter angeben, kann jedoch Argumente für optionale Parameter weglassen. Ein nullabler Bezugstyp (T?) ermöglicht es Argumenten, explizit null zu werden, macht jedoch keinen Parameter optional.
Jeder optionale Parameter weist einen Standardwert als Teil seiner Definition auf. Wenn kein Argument für diesen Parameter gesendet wird, wird der Standardwert verwendet. Ein Standardwert muss eine der folgenden Arten von Ausdrücken sein:
- Ein konstanter Ausdruck, z. B. eine Literalzeichenfolge oder eine Zahl.
- Ein Ausdruck des Formulars
new ValType(), wobeiValTypeein Werttyp ist, z. B. einenumoder einestruct. - Ein Ausdruck des Formulars
default(ValType), wobeiValTypeein Werttyp ist.
Optionale Parameter werden am Ende der Parameterliste nach allen erforderlichen Parametern definiert. Der Aufrufer muss Argumente für alle erforderlichen Parameter und alle optionalen Parameter angeben, die diesen Parametern vorausgehen. Trennzeichentrennte Lücken in der Argumentliste werden nicht unterstützt. Im folgenden Code wird beispielsweise die Instanzmethode ExampleMethod mit einem erforderlichen und zwei optionalen Parametern definiert.
public void ExampleMethod(int required, string optionalstr = "default string", int optionalint = 10)
Der folgende Aufruf von ExampleMethod verursacht einen Compilerfehler, da ein Argument für den dritten Parameter, aber nicht für die zweite angegeben wird.
// anExample.ExampleMethod(3, ,4);
Wenn Sie jedoch den Namen des dritten Parameters kennen, können Sie ein benanntes Argument verwenden, um die Aufgabe auszuführen.
anExample.ExampleMethod(3, optionalint: 4);
IntelliSense verwendet eckige Klammern, um optionale Parameter anzugeben, wie in der folgenden Abbildung dargestellt:
Anmerkung
Sie können optionale Parameter auch mithilfe der .NET-OptionalAttribute-Klasse deklarieren.
OptionalAttribute Parameter erfordern keinen Standardwert. Wenn jedoch ein Standardwert gewünscht wird, sollten Sie die DefaultParameterValueAttribute Klasse verwenden.
Im folgenden Beispiel weist der Konstruktor für ExampleClass einen Parameter auf, der optional ist. Die Instanzmethode ExampleMethod verfügt über einen erforderlichen Parameter, requiredund zwei optionale Parameter, optionalstr und optionalint. Der Code in Main zeigt die verschiedenen Möglichkeiten, wie der Konstruktor und die Methode aufgerufen werden können.
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 can't 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's optional.
public ExampleClass(string name = "Default name")
{
_name = name;
}
// The first parameter, required, has no default value assigned
// to it. Therefore, it isn't optional. Both optionalstr and
// optionalint have default values assigned to them. They're optional.
public void ExampleMethod(int required, string optionalstr = "default string",
int optionalint = 10)
{
Console.WriteLine(
$"{_name}: {required}, {optionalstr}, and {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.
}
Überladungsauflösung für benannte und optionale Argumente
Überladene Methoden sind Methoden, die denselben Namen haben, aber unterschiedliche Signaturen. Die Signatur einer Methode besteht aus dem Namen der Methode und dem Typ und der Art (Wert, Verweis oder Ausgabe) der einzelnen formalen Parameter. Die Überladungsauflösung ist der Prozess der Auswahl der besten Methode, die zwischen mehreren Methoden aufgerufen werden soll, die denselben Namen, aber unterschiedliche Signaturen aufweisen.
Die Verwendung von benannten und optionalen Argumenten wirkt sich auf die Überladungsauflösung wie folgt aus:
- Eine Methode ist ein Kandidat für die Ausführung, wenn jeder parameter optional ist oder nach Name oder Position einem einzelnen Argument in der aufrufenden Anweisung entspricht und dieses Argument in den Typ des Parameters konvertiert werden kann.
- Wenn mehrere Kandidaten gefunden werden, werden Überladungsauflösungsregeln für bevorzugte Konvertierungen auf die explizit angegebenen Argumente angewendet. Ausgelassene Argumente für optionale Parameter werden ignoriert.
- Wenn zwei Kandidaten als gleich gut bewertet werden, geht die Präferenz an einen Kandidaten, der keine optionalen Parameter enthält, für die argumente im Aufruf weggelassen wurden. Überladungsauflösung bevorzugt in der Regel Kandidaten mit weniger Parametern.