Cómo pasar un solo objeto [] a un objeto de parámetros []
Pregunta
Tengo un método que toma parámetros de objeto [] como:
void Foo(params object[] items)
{
Console.WriteLine(items[0]);
}
Cuando paso dos matrices de objetos a este método, funciona bien:
Foo(new object[]{ (object)"1", (object)"2" }, new object[]{ (object)"3", (object)"4" } );
// Output: System.Object[]
Pero cuando paso un solo objeto [], no toma mi objeto [] como primer parámetro, sino que toma todos sus elementos como si quisiera pasarlos uno por uno:
Foo(new object[]{ (object)"1", (object)"2" });
// Output: 1, expected: System.Object[]
¿Cómo paso un único objeto [] como primer argumento a una matriz de parámetros?
Solución
Un simple encasillamiento asegurará que el compilador sepa a qué se refiere en este caso.
Foo((object)new object[]{ (object)"1", (object)"2" }));
Como una matriz es un subtipo de objeto, todo esto funciona.Aunque es una solución un poco extraña, estoy de acuerdo.
Otros consejos
El params
El modificador de parámetros brinda a las personas que llaman una sintaxis abreviada para pasar múltiples argumentos a un método.Hay dos formas de llamar a un método con un params
parámetro:
1) Llamar con una matriz del tipo de parámetro, en cuyo caso el params
La palabra clave no tiene ningún efecto y la matriz se pasa directamente al método:
object[] array = new[] { "1", "2" };
// Foo receives the 'array' argument directly.
Foo( array );
2) O bien, llamar con una lista extendida de argumentos, en cuyo caso el compilador envolverá automáticamente la lista de argumentos en una matriz temporal y la pasará al 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 pasar una matriz de objetos a un método con "params object[]
"parámetro, puede:
1) Cree una matriz contenedora manualmente y pásela directamente al método, como lo menciona lassevk:
Foo( new object[] { array } ); // Equivalent to calling convention 1.
2) O bien, transmitir el argumento a object
, como lo menciona Adán, en cuyo caso el compilador creará la matriz contenedora por usted:
Foo( (object)array ); // Equivalent to calling convention 2.
Sin embargo, si el objetivo del método es procesar múltiples matrices de objetos, puede ser más fácil declararlo con un "explícito".params object[][]
"parámetro.Esto le permitiría pasar múltiples matrices 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 describe este comportamiento y cómo se relaciona con la especificación de C# en una nueva publicación.
Esta es una solución de una línea que involucra LINQ.
var elements = new String[] { "1", "2", "3" };
Foo(elements.Cast<object>().ToArray())
Necesita encapsularlo en otra matriz de objetos [], como esta:
Foo(new Object[] { new object[]{ (object)"1", (object)"2" }});
Una opción es envolverlo en otra matriz:
Foo(new object[]{ new object[]{ (object)"1", (object)"2" } });
Algo feo, pero como cada elemento es una matriz, no puedes simplemente lanzarlo para que el problema desaparezca...como si fuera Foo (elementos de objeto de parámetros), entonces podrías hacer:
Foo((object) new object[]{ (object)"1", (object)"2" });
Alternativamente, podrías intentar definir otra instancia sobrecargada de Foo que requiera solo una 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 }
Otra forma de resolver este problema (no es una buena práctica, pero parece bonita):
static class Helper
{
public static object AsSingleParam(this object[] arg)
{
return (object)arg;
}
}
Uso:
f(new object[] { 1, 2, 3 }.AsSingleParam());