การตรวจจับ IEnumerable“ สถานะเครื่อง”

ฉันเพิ่งอ่านบทความที่น่าสนใจที่เรียกว่าน่ารักเกินไปกับผลตอบแทน c #

มันทำให้ฉันสงสัยว่าวิธีที่ดีที่สุดคือการตรวจสอบว่า IEnumerable เป็นคอลเล็กชันที่นับได้จริงหรือว่าเป็นเครื่องสถานะที่สร้างด้วยคีย์เวิร์ด yield

ตัวอย่างเช่นคุณสามารถแก้ไข DoubleXValue (จากบทความ) เป็นดังนี้:

private void DoubleXValue(IEnumerable<Point> points)
{
    if(points is List<Point>)
      foreach (var point in points)
        point.X *= 2;
    else throw YouCantDoThatException();
}

คำถามที่ 1) มีวิธีที่ดีกว่าในการทำเช่นนี้หรือไม่?

คำถามที่ 2) นี่คือสิ่งที่ฉันควรกังวลเมื่อสร้าง API หรือไม่

คำถามของคุณที่ฉันเข้าใจดูเหมือนว่าจะขึ้นอยู่กับหลักฐานที่ไม่ถูกต้อง ให้ฉันดูว่าฉันสามารถสร้างเหตุผลใหม่ได้หรือไม่:

• บทความที่เชื่อมโยงไปยังอธิบายถึงวิธีที่ลำดับที่สร้างขึ้นโดยอัตโนมัติแสดงพฤติกรรม "ขี้เกียจ" และแสดงให้เห็นว่าสิ่งนี้สามารถนำไปสู่ผลลัพธ์ที่ตอบโต้ได้ง่ายหรือไม่
• ดังนั้นฉันสามารถตรวจสอบว่าอินสแตนซ์ที่กำหนดของ IEnumerable กำลังจะแสดงพฤติกรรมขี้เกียจนี้โดยการตรวจสอบเพื่อดูว่ามันถูกสร้างขึ้นโดยอัตโนมัติ
• ฉันจะทำอย่างไร

ปัญหาคือว่าหลักฐานที่สองเป็นเท็จ แม้ว่าคุณจะสามารถตรวจสอบได้ว่า IEnumerable ที่กำหนดหรือไม่นั้นเป็นผลมาจากการแปลงบล็อกตัววนซ้ำ (และใช่มีวิธีการทำเช่นนั้น) มันจะไม่ช่วยได้เนื่องจากการสันนิษฐานผิด เรามาอธิบายสาเหตุ

class M { public int P { get; set; } }
class C
{
  public static IEnumerable<M> S1()
  {
    for (int i = 0; i < 3; ++i) 
      yield return new M { P = i };
  }

  private static M[] ems = new M[] 
  { new M { P = 0 }, new M { P = 1 }, new M { P = 2 } };
  public static IEnumerable<M> S2()
  {
    for (int i = 0; i < 3; ++i)
      yield return ems[i];
  }

  public static IEnumerable<M> S3()
  {
    return new M[] 
    { new M { P = 0 }, new M { P = 1 }, new M { P = 2 } };
  }

  private class X : IEnumerable<M>
  {
    public IEnumerator<X> GetEnumerator()
    {
      return new XEnum();
    }
    // Omitted: non generic version
    private class XEnum : IEnumerator<X>
    {
      int i = 0;
      M current;
      public bool MoveNext()
      {
        current = new M() { P = i; }
        i += 1;
        return true;
      }
      public M Current { get { return current; } }
      // Omitted: other stuff.
    }
  }

  public static IEnumerable<M> S4()
  {
    return new X();
  }

  public static void Add100(IEnumerable<M> items)
  {
    foreach(M item in items) item.P += 100;
  }
}

เอาล่ะเรามีสี่วิธี S1 และ S2 เป็นลำดับที่สร้างขึ้นโดยอัตโนมัติ S3 และ S4 เป็นลำดับที่สร้างขึ้นด้วยตนเอง ตอนนี้สมมติว่าเรามี:

var items = C.Sn(); // S1, S2, S3, S4
S.Add100(items);
Console.WriteLine(items.First().P);

ผลลัพธ์สำหรับ S1 และ S4 จะเป็น 0 ทุกครั้งที่คุณระบุลำดับคุณจะได้รับการอ้างอิงใหม่กับ M ที่สร้างขึ้น ผลลัพธ์สำหรับ S2 และ S3 จะเท่ากับ 100 ทุกครั้งที่คุณระบุลำดับคุณจะได้รับการอ้างอิงเดียวกันกับ M ที่คุณได้รับครั้งล่าสุด ไม่ว่าจะเป็นรหัสลำดับที่ถูกสร้างขึ้นโดยอัตโนมัติหรือไม่เป็นคำถามที่ว่าวัตถุที่ระบุมีการอ้างอิงตัวตนหรือไม่ ทั้งสองคุณสมบัติ - การสร้างอัตโนมัติและตัวตนของการอ้างอิง - จริงๆแล้วไม่มีอะไรเกี่ยวข้องกัน บทความที่คุณเชื่อมโยงกับ conflates พวกเขาบ้าง

เว้นแต่ว่าผู้ให้บริการลำดับนั้นจะได้รับการบันทึกไว้เช่นเดียวกับการเสนอวัตถุที่มีข้อมูลประจำตัวอ้างอิงอยู่เสมอ

ฉันคิดว่าแนวคิดหลักคือคุณควรปฏิบัติต่อIEnumerable<T>คอลเลกชันใด ๆที่ไม่เปลี่ยนรูป : คุณไม่ควรแก้ไขวัตถุจากมันคุณควรสร้างคอลเลกชันใหม่ด้วยวัตถุใหม่:

private IEnumerable<Point> DoubleXValue(IEnumerable<Point> points)
{
    foreach (var point in points)
        yield return new Point(point.X * 2, point.Y);
}

(หรือเขียนแบบเดียวกันอย่างกระชับยิ่งขึ้นโดยใช้ LINQ Select())

หากคุณต้องการแก้ไขรายการในคอลเลกชันอย่าใช้IEnumerable<T>ใช้IList<T>(หรืออาจเป็นไปได้IReadOnlyList<T>ว่าถ้าคุณไม่ต้องการแก้ไขคอลเลกชันเองมีเพียงรายการในนั้นและคุณอยู่ใน. Net 4.5):

private void DoubleXValue(IList<Point> points)
{
    foreach (var point in points)
        point.X *= 2;
}

วิธีนี้หากมีคนพยายามใช้วิธีการของคุณด้วยIEnumerable<T>ก็จะล้มเหลวในเวลารวบรวม

โดยส่วนตัวฉันคิดว่าปัญหาที่เน้นในบทความนั้นเกิดจากการใช้IEnumerableอินเทอร์เฟซมากเกินไปโดยผู้พัฒนา C # จำนวนมากในปัจจุบัน ดูเหมือนว่าจะเป็นประเภทเริ่มต้นเมื่อคุณต้องการชุดของวัตถุ - แต่มีข้อมูลจำนวนมากที่IEnumerableไม่ได้บอกคุณ ... เป็นเรื่องสำคัญ: ไม่ว่าจะได้รับการแก้ไขหรือไม่ *

หากคุณพบว่าคุณจำเป็นต้องตรวจสอบว่าIEnumerableเป็นจริงIEnumerableหรืออย่างอื่นสิ่งที่เป็นนามธรรมได้รั่วไหลออกมาและคุณอาจอยู่ในสถานการณ์ที่ประเภทพารามิเตอร์ของคุณหลวมเกินไป หากท่านต้องการข้อมูลเพิ่มเติมที่IEnumerableอยู่คนเดียวไม่ได้ให้ให้ความต้องการที่ชัดเจนโดยเลือกหนึ่งในการเชื่อมต่ออื่น ๆ เช่นหรือICollectionIList

แก้ไขสำหรับ downvoters โปรดย้อนกลับและอ่านคำถามอย่างระมัดระวัง OP กำลังขอวิธีในการตรวจสอบให้แน่ใจว่าIEnumerableอินสแตนซ์ถูกทำให้เป็นรูปธรรมก่อนที่จะถูกส่งผ่านไปยังวิธีการ API ของเขา คำตอบของฉันตอบคำถามนั้น มีปัญหาที่กว้างขึ้นเกี่ยวกับวิธีการใช้ที่ถูกต้องIEnumerableและความคาดหวังของรหัสที่วาง OP นั้นขึ้นอยู่กับความเข้าใจผิดของปัญหาที่กว้างกว่านั้น แต่ OP ไม่ได้ถามวิธีการใช้อย่างถูกต้องIEnumerableหรือวิธีการทำงานกับประเภทที่ไม่เปลี่ยนรูป . มันไม่ยุติธรรมที่จะลงคะแนนฉันโดยไม่ตอบคำถามที่ไม่ได้โพสต์

* ผมใช้คำว่าreifyคนอื่น ๆ ใช้หรือstabilize materializeฉันไม่คิดว่าจะมีการประชุมร่วมกันในชุมชน