我有一个采用params object []的方法,例如:
1 2 3 4
| void Foo(params object[] items)
{
Console.WriteLine(items[0]);
} |
当我将两个对象数组传递给此方法时,它可以正常工作:
1 2
| Foo(new object[]{ (object)"1", (object)"2" }, new object[]{ (object)"3", (object)"4" } );
// Output: System.Object[] |
但是,当我传递一个object []时,它并没有将我的object []作为第一个参数,而是像我想要一个一个地传递它们一样,将其所有元素都作为一个参数:
1 2
| Foo(new object[]{ (object)"1", (object)"2" });
// Output: 1, expected: System.Object[] |
如何将单个object []作为第一个参数传递给params数组?
一个简单的类型转换将确保编译器知道您在这种情况下的含义。
1
| Foo((object)new object[]{ (object)"1", (object)"2" })); |
由于数组是对象的子类型,因此可以解决所有问题。不过,我会同意一些奇怪的解决方案。
params参数修饰符为调用者提供了一种将多个参数传递给方法的快捷语法。使用params参数调用方法有两种方法:
1)用参数类型的数组调用,在这种情况下,params关键字无效,该数组直接传递给方法:
1 2 3 4
| object[] array = new[] {"1","2" };
// Foo receives the 'array' argument directly.
Foo( array ); |
2)或者,使用扩展的参数列表进行调用,在这种情况下,编译器将自动将参数列表包装在临时数组中,并将其传递给方法:
1 2 3 4 5 6
| // 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所述:
1
| Foo( new object[] { array } ); // Equivalent to calling convention 1. |
2)或者,如Adam所述,将参数强制转换为object,在这种情况下,编译器将为您创建包装器数组:
1
| Foo( (object)array ); // Equivalent to calling convention 2. |
但是,如果该方法的目标是处理多个对象数组,则使用显式" params object[][]"参数进行声明可能会更容易。这将允许您将多个数组作为参数传递:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| 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 ); |
编辑:Raymond Chen在新帖子中描述了此行为及其与C#规范的关系。
这是涉及LINQ的单线解决方案。
1 2
| var elements = new String[] {"1","2","3" };
Foo(elements.Cast<object>().ToArray()) |
您需要将其封装到另一个object []数组中,如下所示:
1
| Foo(new Object[] { new object[]{ (object)"1", (object)"2" }}); |
解决此问题的另一种方法(虽然不是很好的做法,但看起来很美):
1 2 3 4 5 6 7
| static class Helper
{
public static object AsSingleParam(this object[] arg)
{
return (object)arg;
}
} |
用法:
1
| f(new object[] { 1, 2, 3 }.AsSingleParam()); |
1
| new[] { (object) 0, (object) null, (object) false } |
一种选择是可以将其包装到另一个数组中:
1
| Foo(new object[]{ new object[]{ (object)"1", (object)"2" } }); |
有点丑陋,但是由于每个项目都是一个数组,因此您不能仅将其强制转换以使问题消失……例如,如果它是Foo(参数对象项目),则可以执行以下操作:
1
| Foo((object) new object[]{ (object)"1", (object)"2" }); |
另外,您可以尝试定义另一个仅包含单个数组的Foo重载实例:
1 2 3 4 5 6 7 8 9
| 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 });
} |