วิธีการส่งผ่านวัตถุเดียว [] ไปยังวัตถุ params []

ฉันมีวิธีการที่ใช้วัตถุ params [] เช่น:

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[]

แต่เมื่อฉันส่งวัตถุเดียว [] มันจะไม่ใช้วัตถุของฉัน [] เป็นพารามิเตอร์ตัวแรก แต่จะใช้องค์ประกอบทั้งหมดเหมือนที่ฉันต้องการส่งผ่านทีละรายการ:

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

ฉันจะส่งอ็อบเจ็กต์เดียว [] เป็นอาร์กิวเมนต์แรกไปยังอาร์เรย์พารามิเตอร์ได้อย่างไร

การพิมพ์แบบธรรมดาจะช่วยให้คอมไพเลอร์รู้ว่าคุณหมายถึงอะไรในกรณีนี้

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

เนื่องจากอาร์เรย์เป็นประเภทย่อยของออบเจ็กต์ทั้งหมดนี้ได้ผล วิธีแก้ปัญหาแปลก ๆ ฉันเห็นด้วย

paramsปรับแต่งพารามิเตอร์ให้โทรติดต่อไวยากรณ์ทางลัดสำหรับการส่งผ่านข้อโต้แย้งหลายวิธีที่จะ มีสองวิธีในการเรียกใช้เมธอดด้วย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)สร้างอาร์เรย์ wrapper ด้วยตนเองและส่งตรงไปยังเมธอดดังกล่าวโดยlassevk :

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 );

แก้ไข:เรย์มอนด์เฉินอธิบายพฤติกรรมนี้และวิธีการที่เกี่ยวกับสเปค C # ในการโพสต์ใหม่

นี่เป็นโซลูชันหนึ่งบรรทัดที่เกี่ยวข้องกับ LINQ

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

คุณต้องห่อหุ้มไว้ในอาร์เรย์วัตถุอื่น [] ดังนี้:

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

อีกวิธีหนึ่งในการแก้ปัญหานี้ (ไม่ใช่แนวทางปฏิบัติที่ดี แต่ดูสวยงาม):

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

การใช้งาน:

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

ทางเลือกหนึ่งคือคุณสามารถรวมเข้ากับอาร์เรย์อื่น:

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

น่าเกลียด แต่เนื่องจากแต่ละรายการเป็นอาร์เรย์คุณจึงไม่สามารถโยนมันเพื่อให้ปัญหาหมดไปได้ ... เช่นถ้าเป็น Foo (รายการวัตถุ params) คุณสามารถทำได้:

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 }