Como passar um único objeto [] para um objeto params []

Eu tenho um método que leva params objeto [] como:

void Foo(params object[] items)
{
    Console.WriteLine(items[0]);
}

Quando passo duas matrizes de objetos para esse método, ele funciona bem:

Foo(new object[]{ (object)"1", (object)"2" }, new object[]{ (object)"3", (object)"4" } );
// Output: System.Object[]

Mas quando passo um único objeto [], ele não leva meu objeto [] como o primeiro parâmetro; em vez disso, leva todos os seus elementos como eu queria passar um por um:

Foo(new object[]{ (object)"1", (object)"2" });
// Output: 1, expected: System.Object[]

Como passo um único objeto [] como primeiro argumento para uma matriz de parâmetros?

Um typecast simples garantirá que o compilador saiba o que você quer dizer neste caso.

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

Como uma matriz é um subtipo de objeto, tudo isso funciona. Uma solução estranha, eu concordo.

O paramsmodificador de parâmetro fornece aos chamadores uma sintaxe de atalho para passar vários argumentos para um método. Existem duas maneiras de chamar um método com um paramsparâmetro:

1) Chamando com uma matriz do tipo de parâmetro; nesse caso, a paramspalavra-chave não tem efeito e a matriz é passada diretamente para o método:

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

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

2) Ou, chamando com uma lista estendida de argumentos; nesse caso, o compilador quebra automaticamente a lista de argumentos em uma matriz temporária e a passa para o método:

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

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

Para passar uma matriz de objetos para um método com um params object[]parâmetro " ", você pode:

1) Crie uma matriz de wrapper manualmente e passe-a diretamente para o método, conforme mencionado por lassevk :

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

2) Ou, use o argumento object, como mencionado por Adam , caso em que o compilador criará a matriz do wrapper para você:

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

No entanto, se o objetivo do método é processar várias matrizes de objetos, pode ser mais fácil declará-lo com um params object[][]parâmetro " " explícito . Isso permitiria que você passasse várias matrizes como argumentos:

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

Edit: Raymond Chen descreve esse comportamento e como ele se relaciona com a especificação C # em uma nova postagem .

Esta é uma solução de uma linha que envolve o LINQ.

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

Você precisa encapsulá-lo em outra matriz de objetos [], assim:

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

Outra maneira de resolver esse problema (não é uma boa prática, mas parece bonita):

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

Uso:

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

Uma opção é você pode agrupá-lo em outra matriz:

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

Um pouco feio, mas como cada item é uma matriz, você não pode simplesmente convertê-lo para resolver o problema ... como se fosse Foo (itens de objeto params), então você poderia fazer:

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

Como alternativa, você pode tentar definir outra instância sobrecarregada do Foo, que requer apenas uma única matriz:

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 }