Необязательные аргументы

В версии С# 4.0 внедрено новое средство, повышающее удобство указания аргу­ментов при вызове метода. Это средство называется необязательными аргументами и позволяет определить используемое по умолчанию значение для параметра метода. Данное значение будет использоваться по умолчанию в том случае, если для параме­тра не указан соответствующий аргумент при вызове метода. Следовательно, указывать аргумент для такого параметра не обязательно. Необязательные аргументы позволяют упростить вызов методов, где к некоторым параметрам применяются аргументы, вы­бираемые по умолчанию. Их можно также использовать в качестве "сокращенной" формы перегрузки методов.

Применение необязательного аргумента разрешается при создании необязательного параметра. Для этого достаточно указать используемое по умолчанию значение па­раметра с помощью синтаксиса, аналогичного инициализации переменной. Исполь­зуемое по умолчанию значение должно быть константным выражением. В качестве примера рассмотрим следующее определение метода.

 

 

static void OptArgMeth(int alpha, int beta=10, int gamma = 20) {}

 

В этой строке кода объявляются два необязательных параметра: beta и gamma, при­чем параметру beta по умолчанию присваивается значение 10, а параметру gamma — значение 20. Эти значения используются по умолчанию, если для данных параметров не указываются аргументы при вызове метода. Следует также иметь в виду, что пара­метр alpha не является необязательным. Напротив, это обычный параметр, для кото­рого всегда нужно указывать аргумент.

Принимая во внимание приведенное выше объявление метода OptArgMeth (), последний можно вызвать следующими способами.

// Передать все аргументы явным образом.

OptArgMeth(1, 2, 3);

// Сделать аргумент gamma необязательным.

OptArgMeth(1, 2);

// Сделать оба аргумента beta и gamma необязательными.

OptArgMeth(1);

При первом вызове параметру alpha передается значение 1, параметру beta - значение 2, а параметру gamma - значение 3. Таким образом, все три аргумента за­даются явным образом, а значения, устанавливаемые по умолчанию, не используются.

При втором вызове параметру alpha передается значение 1, а параметру beta - зна­чение 2, но параметру gamma присваивается устанавливаемое по умолчанию значение 20.

И наконец, при третьем вызове упомянутого выше метода параметру alpha пере­дается значение 1, а параметрам beta и gamma присваиваются устанавливаемые по умолчанию значения.

Следует, однако, иметь в виду, что параметр beta не получит устанавливаемое по умолчанию значение, если то же самое не произойдет с параме­тром gamma. Если первый аргумент устанавливается по умолчанию, то и все остальные аргументы должны быть установлены по умолчанию.

Весь описанный выше процесс демонстрируется в приведенном ниже примере программы.

// Продемонстрировать необязательные аргументы.

 

using System; 

 

class OptionArgDemo

{  

static void OptArgMeth(int alpha, int beta=10, int gamma = 20)

{

Console.WriteLine("Here is alpha, beta, and gamma: " +

                 alpha + " " + beta + " " + gamma);

}

 

static void Main()

{

// Передать все аргументы явным образом.

OptArgMeth(1, 2, 3);

 

// Сделать аргумент gamma необязательным.

OptArgMeth(1, 2);

 

// Сделать оба аргумента beta и gamma необязательными.

OptArgMeth(1);

}  

}

 

Результат выполнения данной программы лишь подтверждает применение ис­пользуемых по умолчанию аргументов.

Это аргументы alpha, beta и gamma: 12 3

Это аргументы alpha, beta и gamma: 1 2 20

Это аргументы alpha, beta и gamma: 1 10 20

 

Как следует из приведенного выше результата, если аргумент не указан, то используется его значение, устанавливаемое по умолчанию.

Следует иметь в виду, что все необязательные аргументы должны непременно ука­зываться справа от обязательных. Например, следующее объявление оказывается не­действительным.

int Sample(string name = "пользователь", int userId) { // Ошибка!

Для исправления ошибки в этом объявлении необходимо указать аргумент userId до аргумента паше. Раз уж вы начали объявлять необязательные аргументы, то ука­зывать после них обязательные аргументы нельзя. Например, следующее объявление также оказывается неверным.

int Sample(int accountld, string name = "пользователь", int userId)

{ //Ошибка!

Аргумент name объявляется как необязательный, и поэтому аргумент userId сле­дует указать до аргумента паше (или же сделать его также необязательным).

Помимо методов, необязательные аргументы можно применять в конструкторах, ин­дексаторах и делегатах.

Преимущество необязательных аргументов заключается, в частности, в том, что они упрощают программирующему обращение со сложными вызовами методов и конструкторов. Ведь нередко в методе приходится задавать больше параметров, чем обычно требуется. И в подобных случаях некоторые из этих параметров могут быть сделаны необязательными благодаря аккуратному применению необязательных ар­гументов. Это означает, что передавать нужно лишь те аргументы, которые важны в данном конкретном случае, а не все аргументы, которые в противном случае должны быть обязательными. Такой подход позволяет рационализировать метод и упростить программирующему обращение с ним.

 

Именованные аргументы

Еще одним средством, связанным с передачей аргументов методу, является име­нованный аргумент . Именованные аргументы были внедрены в версии C# 4.0. Как вам должно быть уже известно, при передаче аргументов методу порядок их следования, как правило, должен совпадать с тем порядком, в котором параметры определены в самом методе. Иными словами, значение аргумента присваивается параметру по его позиции в списке аргументов. Данное ограничение призваны преодолеть именованные аргументы. Именованный аргумент позволяет указать имя того параметра, которому присваивается его значение. И в этом случае порядок следования аргументов уже не имеет никакого значения. Таким образом, именованные аргументы в какой-то степени похожи на упоминавшиеся ранее инициализаторы объектов, хотя и отличаются от них своим синтаксисом.

Для указания аргумента по имени служит следующая форма синтаксиса.

имя_параметра : значение

Здесь имя_параметра обозначает имя того параметра, которому передается зна­чение . Разумеется, имя_параметра должно обозначать имя действительного параме­тра для вызываемого метода.

Ниже приведен простой пример, демонстрирующий применение именованных аргументов. В этом примере создается метод IsFactor(), возвращающий логическое значение true, если первый его параметр нацело делится на второй параметр.

Листинг 8.26

// Применить именованные аргументы.

 

using System; 

 

class NamedArgsDemo

{  

 

// Выяснить, делится ли одно значение нацело на другое.

static bool IsFactor(int val, int divisor)

{

if((val % divisor) == 0) return true;

return false;

}

 

static void Main()

{

// Ниже демонстрируются разные способы вызова метода IsFactor()

 

// Вызов с использованием позиционных аргументов.

if(IsFactor(10, 2))

Console.WriteLine("2 множитель 10.");

 

// Вызов с использованием именованных аргументов.

if(IsFactor(val :10, divisor: 2))

Console.WriteLine("2 множитель 10.");

 

// Для именованного аргумента порядок указания не имеет значения.

if(IsFactor(divisor: 2, val: 10))

Console.WriteLine("2 множитель 10.");

 

// Применить как позиционный, так и именованный аргументы.

if(IsFactor(10, divisor: 2))

Console.WriteLine("2 множитель 10.");

}  

}

Выполнение этого кода дает следующий результат.

2 - множитель 10.

2 - множитель 10.

2 - множитель 10.

2 - множитель 10.

Как видите, при каждом вызове метода IsFactor() получается один и тот же результат.

Помимо демонстрации именованного аргумента в действии, приведенный выше пример кода иллюстрирует две важные особенности именованных аргументов. Во-первых, порядок следования аргументов не имеет никакого значения. Например, два следующих вызова метода IsFactor() совершенно равнозначны.

IsFactor(val :10, divisor: 2)

IsFactor(divisor: 2, val: 10)

Независимость от порядка следования является главным преимуществом имено­ванных аргументов. Это означает, что запоминать (или даже знать) порядок следо­вания параметров в вызываемом методе совсем не обязательно. Для работы с СОМ- интерфейсами это может быть очень удобно. И во-вторых, позиционные аргументы можно указывать вместе с именованными в одном и том же вызове, как показано в следующем примере.

IsFactor(10, divisor: 2)

Следует, однако, иметь в виду, что при совместном использовании именованных и позиционных аргументов все позиционные аргументы должны быть указаны перед любыми именованными аргументами.

Именованные аргументы можно также применять вместе с необязательными аргу­ментами. Покажем это на примере вызова метода Display(), рассматривавшегося в предыдущем разделе.

// Указать все аргументы по имени.

Display(stop: 10, str: "это простой тест", start: 0);

 

// Сделать аргумент start устанавливаемым по умолчанию.

Display(stop: 10, str: "это простой тест") ;

 

// Указать строку по позиции, аргумент stop — по имени by name,

// тогда как аргумент start — устанавливаемым по умолчанию

Display("это простой тест", stop: 10);

Вообще говоря, комбинация именованных и необязательных аргументов позволяет упростить вызовы сложных методов со многими параметрами.

Синтаксис именованных аргументов более многословен, чем у обычных позицион­ных аргументов, и поэтому для вызова методов чаще всего применяются позиционные аргументы. Но в тех случаях, когда это уместно, именованные аргументы могут быть использованы довольно эффективно.

Помимо методов, именованные и необязательные аргументы могут применяться в конструкторах, индексаторах и делегатах.