синтаксис распространения в c #? [Дубликат]

params также позволяет вызывать метод с одним аргументом.

private static int Foo(params int[] args) {
    int retVal = 0;
    Array.ForEach(args, (i) => retVal += i);
    return retVal;
}

i.e. Foo(1); вместо Foo(new int[] { 1 });. Может быть полезно для сокращений в сценариях, где вам может потребоваться передать только одно значение, а не весь массив. Он по-прежнему обрабатывается таким же образом в методе, но дает некоторые конфеты для вызова таким образом.

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

addTwoEach(10, 2, 4, 6)

, тогда как со второй формой вы должны использовать массив в качестве параметра

addTwoEach(new int[] {10,2,4,6})

Не нужно создавать методы перегрузки, просто используйте один единственный метод с параметрами, как показано ниже

// Call params method with one to four integer constant parameters.
//
int sum0 = addTwoEach();
int sum1 = addTwoEach(1);
int sum2 = addTwoEach(1, 2);
int sum3 = addTwoEach(3, 3, 3);
int sum4 = addTwoEach(2, 2, 2, 2);

Одна опасность с params Ключевым словом является, если после Звонки на метод были закодированы,

1. кто-то случайно / намеренно удаляет один или несколько Требуется Параметры из подписи метода и
2. требуется один / более Параметры непосредственно перед параметром params до изменения подписи были совместимы с типом params Параметр

Эти вызовы будут продолжать компилироваться с одним или несколькими выражениями, ранее предназначенными для required . Параметры обрабатываются как необязательный параметр params. Я просто столкнулся с худшим возможным случаем этого: параметр params был для Type object[].

Это примечательно, потому что разработчики привыкли к тому, что компилятор шлепает их запястья с гораздо более распространенным сценарий, в котором параметры удаляются из метода со всеми параметрами required (потому что ожидается ожидаемое число ожидаемых параметров).

Для меня это не стоит ярлыка. (Type)[] без params будет работать с 0 до бесконечности № параметров без необходимости переопределения. В худшем случае вам придется добавить , new (Type) [] {} к вызовам, где он не применяется.

Btw, imho, самая безопасная (и наиболее читаемая практика):

1. проходят через Именованные параметры (которые мы теперь можем сделать даже в C # ~ 2 десятилетий после того, как мы могли бы в VB; P) (потому что: 1.1 это только , который гарантирует предотвращение непреднамеренных значений, переданных параметрам после порядка параметров, совпадающего типа и / или изменения счетчика после того, как Calls были закодированы, 1.2. уменьшает , эти шансы после изменения значения параметра, потому что вероятное новое имя идентификатора, отражающее новое значение, находится рядом с переданным ему значением, 1.3. он избегает необходимости подсчитывать запятые и переходить назад и выйти из Call to Signature чтобы увидеть, что передается Expression для параметра Parameter, и 1.4. если вы должны использовать необязательные параметры (params или нет), он позволяет вам искать вызовы, в которых проходит конкретный необязательный параметр (и, следовательно, скорее всего, это не или в лизинге t имеет возможность быть не значением по умолчанию), (ПРИМЕЧАНИЕ: Причины 1.2. и 1.3. может облегчить и уменьшить вероятность ошибки даже при кодировании начальных вызовов, не говоря уже о том, что вызовы должны быть прочитаны и / или изменены.))

и

2. сделайте это ONE - PARAMETER - PER - LINE для лучшей удобочитаемости (потому что: 2.1 он менее загроможден и 2.2. он избегает необходимости прокручивать вправо и назад назад (и должен делать это PER - LINE, так как большинство смертных может " t читать левую часть нескольких строк, прокручивать вправо и читать правую часть)).

ПРИМЕЧАНИЕ:

1. Передача в переменных, чьи имена отражают параметры 'не помогает, когда: 1.1. вы переходите в Literal Constants (т. е. просто 0/1 или true / false, что даже «лучшие практики» могут не потребовать использования Именованной константы, и их назначение не может быть легко выведено из имени метода) 1.2. Метод значительно ниже / более общий, чем Caller, так что вы не захотите / не сможете называть свои переменные такими же / подобными параметрам (или наоборот) или 1.3. вы переупорядочиваете / заменяете параметры в подписи, что может привести к тому, что предыдущие вызовы все еще компилируются, потому что типы бывают , чтобы по-прежнему быть совместимыми.
2. Наличие функции автоматической обмотки, такой как VS, устраняет только ОДИН (# 2.2) из ​​6 причин, которые я дал выше. До VS VS 2015 он не был автоматически отступ (!?! Действительно, MS?!?), Что увеличивает серьезность разума № 2.1.

VS должен иметь опцию, которая генерирует фрагменты метода вызова с Именованными параметрами (по одной на строку, конечно, P) и параметр компилятора, который требует Именованные параметры (аналогично по понятию Option Explicit в VB, который, кстати, требование было умножено один раз так же, как и возмутительно, но сейчас довольно требуется по «лучшей практике»). Фактически, «в мой день»;), в 1991 году, всего за несколько месяцев до моей карьеры, еще до того, как я использовал (или даже видел) язык с Именованными параметрами, у меня был анти-sheeple / «просто потому, что вы можете, не означает, что вы должны / не слепо« разрезать концы жаркого », достаточно, чтобы имитировать его (используя встроенные комментарии), не увидев, что кто-то это делает. Не использовать Именованные параметры (а также другой синтаксис, который сохраняет «драгоценные» нажатия клавиш исходного кода) является реликтом эры перфокарта, когда большинство этих синтаксисов началось. Нет никакого оправдания для этого с современным оборудованием и IDE и гораздо более сложным программным обеспечением, где читаемость много, многое, MUCH более важно. «Код читается гораздо чаще, чем написано». Пока вы не дублируете неавтоматизированный код, каждое нажатие клавиши может стоить экспоненциально больше, когда кто-то (даже вы) пытается прочитать его позже.

Добавление ключевого слова params показывает, что вы можете передать несколько параметров при вызове этого метода, который невозможен без его использования. Чтобы быть более конкретным:

static public int addTwoEach(params int[] args)
{
    int sum = 0;

    foreach (var item in args)
    {
        sum += item + 2;
    }

    return sum;
}

Когда вы вызовете метод выше, вы можете вызвать его одним из следующих способов:

1. addTwoEach()
2. addTwoEach(1)
3. addTwoEach(new int[]{ 1, 2, 3, 4 })

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