Argumenty nazwane i opcjonalne (Przewodnik programowania w języku C#)

Artykuł
06/10/2015

Visual C# 2010wprowadza argumenty nazwane i opcjonalne.Nazwanych argumentów umożliwiają określenie argumentu dla określonego parametru kojarząc argument o nazwie parametru zamiast parametru pozycji na liście parametrów.Opcjonalne argumenty umożliwiają pominąć argumenty dla niektórych parametrów.Obie techniki służą metody, indeksatory, konstruktorów i delegatów.

Użycie argumentów nazwanych i opcjonalne argumenty są oceniane w kolejności, w jakiej pojawiają się na liście argumentów, nie listy parametrów.

Parametry nazwane i opcjonalny, gdy są używane razem, umożliwiają podać argumenty tylko kilka parametrów z listy parametrów opcjonalnych.Ta funkcja znacznie ułatwia wywołania interfejsów COM, takie jak API automatyzacji programu Microsoft Office.

Nazwanych argumentów

Nazwanych argumentów pozbawione potrzebę Pamiętaj lub wyszukać kolejność parametrów listy parametrów metod nazywane.Parametr dla każdego argumentu może określony przez parametr Nazwa.Na przykład funkcja, która oblicza się, że wskaźnik masy ciała (BMI) może być wywoływana w standardowy sposób wysyłając argumenty, waga i wysokość według położenia w porządku wymaganym przez funkcję.

CalculateBMI(123, 64);

Jeśli użytkownik nie pamięta kolejność parametrów, ale znasz ich nazwy, można wysłać argumenty w kolejności albo, najpierw waga pierwszej lub wysokość.

CalculateBMI(weight: 123, height: 64);

CalculateBMI(height: 64, weight: 123);

Nazwanych argumentów również poprawić czytelność kodu identyfikując reprezentuje każdego argumentu.

Nazwany argument można wykonać pozycyjne argumenty, jak pokazano poniżej.

CalculateBMI(123, height: 64);

Jednakże argument pozycyjne nie może następować nazwany argument.Poniższa instrukcja powoduje wystąpienie błędu kompilatora.

//CalculateBMI(weight: 123, 64);

Przykład

Poniższy kod implementuje przykłady z tej sekcji.

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);
    }
}

Opcjonalne argumenty

Definicja metody, Konstruktor, indeksator lub pełnomocnika można określić, że jego parametry są wymagane, lub że są opcjonalne.Każde wywołanie musi dostarczyć argumenty dla wszystkich wymaganych parametrów, ale można pominąć argumenty dla parametrów opcjonalnych.

Każdy opcjonalny parametr ma wartość domyślną jako część jego definicję.Jeśli argument nie jest wysyłany dla tego parametru, używana jest wartość domyślna.Wartość domyślna musi być jednym z następujących wyrażeń:

wyrażenie stałe;
wyrażenie postaci new ValType(), gdzie ValType jest typ wartości, takich jak enum lub struct;
wyrażenie postaci default(ValType), gdzie ValType jest typ wartości.

Parametry opcjonalne są definiowane na końcu listy parametrów po wszelkich wymaganych parametrów.Jeśli wywołujący przewiduje dla dziedziczenia parametrów opcjonalnych jeden argument, musi zapewniać argumenty dla wszystkich poprzednich parametrów opcjonalnych.Luki oddzielone przecinkami, na liście argumentów nie są obsługiwane.Na przykład w poniższym kodzie wystąpienia metoda ExampleMethod jest zdefiniowana z wymaganą i dwa parametry opcjonalne.

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

Następujące wywołanie do ExampleMethod powoduje błąd kompilatora, ponieważ argument jest świadczone dla trzeciego parametru, ale nie dla drugiego.

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

Jednakże jeśli znasz nazwę trzeci parametr, nazwany argument można użyć do wykonania zadania.

anExample.ExampleMethod(3, optionalint: 4);

Technologia IntelliSense używa nawiasy w celu wskazania parametry opcjonalne, jak pokazano na poniższej ilustracji.

Parametry opcjonalne w ExampleMethod

Technologia IntelliSense szybkie informacje dla metody ExampleMethod.

[!UWAGA]

Parametry opcjonalne można również zadeklarować za pomocą.NET OptionalAttribute klasy.OptionalAttributeParametry nie wymagają wartość domyślną.

Przykład

W poniższym przykładzie konstruktora dla ExampleClass ma jeden parametr, który jest opcjonalny.Metoda instancji ExampleMethod ma jeden parametr wymagane, requiredi dwa parametry opcjonalne, optionalstr i optionalint.Kod w Main pokazuje różne sposoby, w którym konstruktor i metoda może być wywoływana.

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.

}

Interfejsy COM.

Argumenty nazwane i opcjonalne, razem z obsługą obiekty dynamiczne i inne rozszerzenia w znacznym stopniu poprawić interoperacyjność z interfejsów API modelu COM, takie jak interfejsów API automatyzacji pakietu Office.

Na przykład Autoformatowanie metody w programie Microsoft Office Excel zakres interfejs ma parametry siedmiu, z których wszystkie są opcjonalne.Te parametry są przedstawione na poniższej ilustracji.

Parametry autoformatowania

Technologia IntelliSense szybkie informacje o metodzie Autoformatowanie.

W C# 3.0 i wcześniejsze wersje argument jest wymagana dla każdego parametru, jak pokazano w poniższym przykładzie.

// 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);

Jednakże, mogą znacznie ułatwić wywołanie AutoFormat za pomocą nazwanych i opcjonalne argumenty, wprowadzone w C# w wersji 4.0.O nazwie i argumentów opcjonalnych pozwala pominąć argument opcjonalny parametr, jeśli nie chcesz zmienić domyślną wartość parametru.W poniższym wywołaniu wartość jest określona tylko dla jednego z siedmiu parametrów.

// 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 );

Aby uzyskać dodatkowe informacje i przykłady, zobacz Porady: użycie argumentów nazwanych i opcjonalnych w programowaniu Office (Przewodnik programowania w języku C#) i Porady: uzyskiwanie dostępu do obiektów międzyoperacyjności pakietu Office za pomocą funkcji Visual C# (Przewodnik po programowaniu w języku C#).

Rozpoznanie przeciążenia

Użycie argumentów nazwanych i opcjonalne wpływa rozdzielczość przeciążania w następujący sposób:

Metoda, indeksowanie lub konstruktora jest kandydatem do wykonania, jeśli każdego z jego parametrów jest opcjonalna lub odpowiada według nazwy lub według pozycji do pojedynczy argument w instrukcji wywołującego, i że argument można konwertować na typ parametru.
Jeśli zostanie znaleziony więcej niż jednego kandydata, przeciążenie rozdzielczość reguły dla konwersji preferowane są stosowane do argumenty, które są wyraźnie określone.Pominiętych argumentów opcjonalnych parametrów są ignorowane.
Jeśli dwóch kandydatów, którzy zostaną ocenione jako równie dobre, preferencji prowadzi do kandydat, który nie ma parametrów opcjonalnych, dla których argumenty zostały pominięte w wywołaniu.Jest to konsekwencją ogólnych preferencji rozdzielczość przeciążania dla kandydatów, które mają mniej parametrów.

Specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz Specyfikacja języka C#. Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.

Zobacz też

Udostępnij za pośrednictwem

Argumenty nazwane i opcjonalne (Przewodnik programowania w języku C#)

Nazwanych argumentów

Przykład

Opcjonalne argumenty

Przykład

Interfejsy COM.

Rozpoznanie przeciążenia

Specyfikacja języka C#

Zobacz też

Zadania

Informacje

Inne zasoby

Dodatkowe zasoby