Angiv navngivne og valgfri metodeargumenter

Fuldført

Med navngivne argumenter kan du angive et argument for en parameter ved at matche argumentet med dets navn i stedet for med dets placering på parameterlisten. Valgfrie argumenter gør det muligt at udelade argumenter for nogle parametre. Begge teknikker kan bruges sammen med metoder, indekseringsmaskiner, konstruktører og stedfortrædere.

Når du bruger navngivne og valgfrie argumenter, evalueres argumenterne i den rækkefølge, de vises i på argumentlisten, ikke på parameterlisten.

Navngivne og valgfrie parametre giver dig mulighed for at angive argumenter for valgte parametre. Denne funktion letter kald til COM-grænseflader, f.eks. Microsoft Office Automation-API'er.

Navngivne argumenter

Navngivne argumenter frigør dig fra at matche rækkefølgen af argumenter med rækkefølgen af parametre på parameterlisterne for kaldte metoder. Argumentet for hver parameter kan angives ved parameternavn.

Seddel

Navngivne argumenter forbedrer læsbarheden af din kode ved at identificere, hvad hvert argument repræsenterer.

Overvej en metode, der bruger følgende metodesignatur:

static void PrintOrderDetails(string sellerName, int orderNum, string productName)
{
    // Code to print the order details
}

Denne metode kan kaldes uden at bruge navngivne argumenter, så længe argumenterne er i den korrekte rækkefølge (defineret af metodesignaturen):

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

Hvis du ikke kan huske rækkefølgen af parametrene, men kender deres navne, kan du sende argumenterne i en vilkårlig rækkefølge.

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

Når de bruges sammen med placeringsargumenter, er navngivne argumenter gyldige, så længe de bruges på den korrekte placering.

Følgende eksempel fungerer korrekt, fordi: Parameteren productName er udtrykkeligt navngivet, efterfølges ikke af nogen positionelle argumenter og er på den korrekte placering.

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

Positionelle argumenter, der følger efter eventuelle navngivne argumenter, der ikke er i rækkefølge, er ugyldige.

// This generates CS1738: Named argument specifications must appear after all fixed arguments have been specified.
PrintOrderDetails(productName: "Red Mug", 31, "Gift Shop");

Valgfrie argumenter

En metodedefinition kan angive, om parametrene er obligatoriske eller valgfrie. Ethvert kald skal angive argumenter for alle påkrævede parametre, men kan udelade argumenter for valgfrie parametre. En referencetype, der kan være null (T?), gør det muligt eksplicit at null argumenter, men gør i sagens natur ikke en parameter valgfri.

Hver valgfri parameter har en standardværdi som en del af definitionen. Hvis der ikke sendes noget argument for parameteren, bruges standardværdien. En standardværdi skal være en af følgende typer udtryk:

• Et konstantudtryk, f.eks. en konstantstreng eller et tal.
• Et udtryk i formularen new ValType(), hvor ValType er en værditype, f.eks. en enum eller en struct.
• Et udtryk for formularen default(ValType), hvor ValType er en værditype.

Valgfrie parametre defineres i slutningen af parameterlisten efter eventuelle påkrævede parametre. Kalderen skal angive argumenter for alle påkrævede parametre og eventuelle valgfri parametre, der går forud for dem, den angiver. Kommaseparerede mellemrum på argumentlisten understøttes ikke. I følgende kode defineres forekomstmetoden ExampleMethod f.eks. med én påkrævet og to valgfri parametre.

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

Følgende kald til ExampleMethod forårsager en compilerfejl, fordi der er angivet et argument for den tredje parameter, men ikke for det andet.

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

Men hvis du kender navnet på den tredje parameter, kan du bruge et navngivet argument til at udføre opgaven.

anExample.ExampleMethod(3, optionalint: 4);

IntelliSense bruger kantede parenteser til at angive valgfri parametre, som vist i følgende illustration:

Seddel

Du kan også deklarere valgfri parametre ved hjælp af klassen .NET OptionalAttribute. OptionalAttribute parametre kræver ikke en standardværdi. Men hvis du ønsker en standardværdi, kan du overveje at bruge klassen DefaultParameterValueAttribute.

I følgende eksempel har konstruktøren for ExampleClass én parameter, som er valgfri. Forekomstmetoden ExampleMethod har én påkrævet parameter, requiredog to valgfri parametre, optionalstr og optionalint. Koden i Main viser de forskellige måder, konstruktøren og metoden kan aktiveres på.

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.
}

Overbelastning af navngivne og valgfri argumenter

Overbelastede metoder er metoder, der har samme navn, men forskellige signaturer. Signaturen for en metode består af navnet på metoden og typen og typen (værdi, reference eller output) af hver af dens formelle parametre. Overbelastningsopløsning er processen med at vælge den bedste metode til at kalde blandt flere metoder, der har samme navn, men forskellige signaturer.

Brug af navngivne og valgfri argumenter påvirker overbelastningsopløsningen på følgende måder:

• En metode er kandidat til udførelse, hvis hver af parametrene enten er valgfri eller efter navn eller position svarer til et enkelt argument i kaldsætningen, og dette argument kan konverteres til parameterens type.
• Hvis der findes mere end én kandidat, anvendes overbelastningsregler for foretrukne konverteringer på de argumenter, der udtrykkeligt er angivet. Udeladte argumenter for valgfri parametre ignoreres.
• Hvis to kandidater vurderes til at være lige gode, foretrækkes en kandidat, der ikke har valgfrie parametre, for hvilke argumenterne blev udeladt i kaldet. Overbelastningsopløsning foretrækker generelt kandidater, der har færre parametre.