varargs / params object [], но различают фактический объект [] input и varargs input (s) [duplicate]

Это однострочное решение, включающее LINQ.

var elements = new String[] { "1", "2", "3" };
Foo(elements.Cast<object>().ToArray())

Модификатор параметра params дает вызывающим операторам синтаксис ярлыков для передачи нескольких аргументов методу. Существует два способа вызова метода с параметром params:

1) Вызов с массивом типа параметра, и в этом случае ключевое слово params не имеет эффекта, и массив передается напрямую к методу:

object[] array = new[] { "1", "2" };

// Foo receives the 'array' argument directly.
Foo( array );

2) Или вызов с расширенным списком аргументов, и в этом случае компилятор автоматически обернет список аргументов во временном массиве и передаст это методу:

// Foo receives a temporary array containing the list of arguments.
Foo( "1", "2" );

// This is equivalent to:
object[] temp = new[] { "1", "2" );
Foo( temp );

Чтобы передать массив объектов методу с параметром «params object[]», вы можете:

1) Создать массив обертки вручную и передать это непосредственно методу, как указано в lassevk :

Foo( new object[] { array } );  // Equivalent to calling convention 1.

2) Или, передайте аргумент object, как указано в Adam , и в этом случае компилятор создаст для вас массив-обертку:

Foo( (object)array );  // Equivalent to calling convention 2.

Однако, если целью метода является обработка нескольких объектных массивов, может быть проще объявить его с помощью явного параметра «params object[][]». Это позволит вам передать несколько массивов в качестве аргументов:

void Foo( params object[][] arrays ) {
  foreach( object[] array in arrays ) {
    // process array
  }
}

...
Foo( new[] { "1", "2" }, new[] { "3", "4" } );

// Equivalent to:
object[][] arrays = new[] {
  new[] { "1", "2" },
  new[] { "3", "4" }
};
Foo( arrays );

Изменить: Раймонд Чен описывает это поведение и как он относится к спецификации C # в новой записи .

Вам необходимо инкапсулировать его в другой массив [] []:

Foo(new Object[] { new object[]{ (object)"1", (object)"2" }});

Один вариант - вы можете перенести его в другой массив:

Foo(new object[]{ new object[]{ (object)"1", (object)"2" } });

Вид уродливого, но поскольку каждый элемент является массивом, вы не можете просто бросить его, чтобы проблема исчезла. .. как если бы это были Foo (объекты объектов params), то вы могли бы просто сделать:

Foo((object) new object[]{ (object)"1", (object)"2" });

В качестве альтернативы вы могли бы попытаться определить другой перегруженный экземпляр Foo, который принимает только один массив:

void Foo(object[] item)
{
    // Somehow don't duplicate Foo(object[]) and
    // Foo(params object[]) without making an infinite
    // recursive call... maybe something like
    // FooImpl(params object[] items) and then this
    // could invoke it via:
    // FooImpl(new object[] { item });
}

new[] { (object) 0, (object) null, (object) false }

Другой способ решить эту проблему (это не очень хорошая практика, но выглядит красиво):

static class Helper
{
    public static object AsSingleParam(this object[] arg)
    {
       return (object)arg;
    }
}

Использование:

f(new object[] { 1, 2, 3 }.AsSingleParam());