Como passar um único objeto[] para um objeto params[]
Pergunta
Eu tenho um método que usa parâmetros object[] como:
void Foo(params object[] items)
{
Console.WriteLine(items[0]);
}
Quando passo dois arrays de objetos para este método, ele funciona bem:
Foo(new object[]{ (object)"1", (object)"2" }, new object[]{ (object)"3", (object)"4" } );
// Output: System.Object[]
Mas quando eu passo um único objeto[], ele não pega meu objeto[] como o primeiro parâmetro, em vez disso ele pega todos os seus elementos como eu queria passá-los 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?
Solução
Um typecast simples garantirá que o compilador saiba o que você quer dizer neste caso.
Foo((object)new object[]{ (object)"1", (object)"2" }));
Como um array é um subtipo de objeto, tudo isso funciona.Porém, é uma solução um pouco estranha, concordo.
Outras dicas
O params
O modificador 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 params
parâmetro:
1) Chamando com um array do tipo de parâmetro, nesse caso o params
palavra-chave não tem efeito e o array é passado 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, caso em que o compilador agrupará automaticamente a lista de argumentos em um array temporário e passará isso 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 um array de objetos para um método com um "params object[]
" parâmetro, você pode:
1) Crie um array wrapper manualmente e passe-o diretamente para o método, conforme mencionado por Lassevk:
Foo( new object[] { array } ); // Equivalent to calling convention 1.
2) Ou lance o argumento para object
, como mencionado por Adão, nesse caso o compilador criará o array wrapper para você:
Foo( (object)array ); // Equivalent to calling convention 2.
No entanto, se o objetivo do método for processar vários arrays de objetos, pode ser mais fácil declará-lo com um "params object[][]
"parâmetro.Isso permitiria que você passasse vários arrays 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 );
Editar: 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 envolvendo LINQ.
var elements = new String[] { "1", "2", "3" };
Foo(elements.Cast<object>().ToArray())
Você precisa encapsulá-lo em outro array object[], assim:
Foo(new Object[] { new object[]{ (object)"1", (object)"2" }});
Uma opção é agrupá-lo em outro array:
Foo(new object[]{ new object[]{ (object)"1", (object)"2" } });
Meio feio, mas como cada item é um array, você não pode simplesmente lançá-lo para resolver o problema...como se fosse Foo(params object items), então você poderia simplesmente fazer:
Foo((object) new object[]{ (object)"1", (object)"2" });
Alternativamente, você poderia tentar definir outra instância sobrecarregada de Foo que usa apenas um único array:
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 }
Outra maneira de resolver este problema (não é uma prática tão boa, mas parece linda):
static class Helper
{
public static object AsSingleParam(this object[] arg)
{
return (object)arg;
}
}
Uso:
f(new object[] { 1, 2, 3 }.AsSingleParam());