如何将单个对象[]传递给参数对象[]

StackOverflow https://stackoverflow.com/questions/36350

  •  09-06-2019
  •  | 
  •  

题

我有一个采用 params object[] 的方法，例如：

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

当我将两个对象数组传递给此方法时，它工作正常：

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

但是当我传递单个 object[] 时，它不会将我的 object[] 作为第一个参数，而是将其所有元素就像我想逐个传递它们一样：

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

如何将单个 object[] 作为第一个参数传递给 params 数组？

有帮助吗？

解决方案

简单的类型转换将确保编译器知道您在这种情况下的意思。

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

由于数组是对象的子类型，所以这一切都可以解决。虽然这个解决方案有点奇怪，但我同意。

其他提示

这 params 参数修饰符为调用者提供了将多个参数传递给方法的快捷语法。有两种方法可以调用带有 a 的方法 params 范围：

1) 使用参数类型的数组进行调用，在这种情况下 params 关键字不起作用，数组直接传递给方法：

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

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

2) 或者，使用扩展的参数列表进行调用，在这种情况下，编译器会自动将参数列表包装在临时数组中并将其传递给方法：

// 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) 手动创建一个包装数组并将其直接传递给方法，如所述 拉塞夫克:

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

2) 或者，将参数转换为 object, ，正如所提到的 亚当, ，在这种情况下，编译器将为您创建包装数组：

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


但是，如果该方法的目标是处理多个对象数组，则使用显式“声明它可能会更容易”params object[][]“ 范围。这将允许您传递多个数组作为参数：

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 的单行解决方案。

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

您需要将其封装到另一个 object[] 数组中，如下所示：

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

一种选择是将其包装到另一个数组中：

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

有点难看，但由于每个项目都是一个数组，你不能仅仅通过转换它来解决问题......例如如果它是 Foo(params object items)，那么你可以这样做：

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

或者，您可以尝试定义 Foo 的另一个重载实例，它只需要一个数组：

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 }

解决这个问题的另一种方法（这不是很好的做法，但看起来很漂亮）：

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

用法：

f(new object[] { 1, 2, 3 }.AsSingleParam());
许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top