c# - valid - remarks/>

Cómo pasar un único objeto[] a un objeto params

Question

Tengo un método que toma params object [] 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 param, 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 params?

Answer 1

El modificador del parámetro params proporciona a los llamantes una sintaxis de acceso directo para pasar múltiples argumentos a un método. Hay dos formas de llamar a un método con un parámetro params :

1) Llamar con una matriz del tipo de parámetro, en cuyo caso la palabra clave params 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, llamando con una lista extendida de argumentos, en cuyo caso el compilador automáticamente ajustará 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 un params object[] " params object[] ", puede:

1) Cree un arreglo de envoltura manualmente y páselo directamente al método, como lo menciona lassevk :

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

2) O bien, eche el argumento a object , como lo menciona Adam , 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 matrices de objetos múltiples, puede ser más fácil declararlo con un parámetro explícito de " params object[][] ". 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 C # en una nueva publicación .

Answer 2

Esta es una solución de una línea que involucra a LINQ.

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

Answer 3

Necesitas encapsularlo en otra matriz de objetos [], como esta:

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

Answer 4

Otra forma de resolver este problema (no es tan buena práctica, pero se ve bella):

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

Uso:

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

Answer 5

Un simple encasillado asegurará que el compilador sepa lo que quiere decir 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 extraña, estoy de acuerdo.

Answer 6

Una opción es que puedes 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 desaparezca el problema ... como si fuera Foo (elementos del objeto params), entonces podrías hacer lo siguiente:

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

Alternativamente, puedes intentar definir otra instancia sobrecargada de Foo que solo tome una ú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 });
}

Answer 7

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