Phát hiện máy tính nhà nước IEn Countable

Tôi vừa đọc một bài viết thú vị có tên Trở nên quá dễ thương với lợi nhuận của c #

Nó khiến tôi tự hỏi cách tốt nhất là phát hiện xem IEnumerable là một bộ sưu tập có thể đếm được thực sự hay nếu đó là một máy trạng thái được tạo bằng từ khóa suất.

Ví dụ: bạn có thể sửa đổi DoubleXValue (từ bài viết) thành một cái gì đó như:

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

Câu hỏi 1) Có cách nào tốt hơn để làm điều này không?

Câu hỏi 2) Đây có phải là điều tôi nên lo lắng khi tạo API không?

Câu hỏi của bạn, theo tôi hiểu, dường như được dựa trên một tiền đề không chính xác. Hãy để tôi xem nếu tôi có thể xây dựng lại lý do:

• Bài viết được liên kết mô tả cách các chuỗi được tạo tự động thể hiện hành vi "lười biếng" và cho thấy cách điều này có thể dẫn đến kết quả phản trực quan.
• Do đó, tôi có thể phát hiện xem một phiên bản cụ thể của IEnumerable sẽ thể hiện hành vi lười biếng này hay không bằng cách kiểm tra xem liệu nó có được tạo tự động hay không.
• Làm thế nào để làm điều đó?

Vấn đề là tiền đề thứ hai là sai. Ngay cả khi bạn có thể phát hiện xem một IEnumerable cụ thể có phải là kết quả của phép chuyển đổi khối lặp hay không (và vâng, có nhiều cách để làm điều đó) sẽ không có ích vì giả định là sai. Hãy minh họa tại sao.

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

Được rồi, chúng tôi có bốn phương pháp. S1 và S2 là các chuỗi được tạo tự động; S3 và S4 là các chuỗi được tạo thủ công. Bây giờ giả sử chúng ta có:

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

Kết quả cho S1 và S4 sẽ là 0; mỗi khi bạn liệt kê chuỗi, bạn sẽ có một tham chiếu mới đến một M được tạo. Kết quả cho S2 và S3 sẽ là 100; mỗi khi bạn liệt kê trình tự, bạn sẽ có cùng tham chiếu đến M bạn đã nhận được lần cuối cùng. Liệu mã trình tự có được tạo tự động hay không trực giao với câu hỏi liệu các đối tượng được liệt kê có nhận dạng tham chiếu hay không. Hai thuộc tính đó - tạo tự động và nhận dạng tham chiếu - thực sự không liên quan gì đến nhau. Bài viết bạn liên kết để xúi giục họ phần nào.

Trừ khi một nhà cung cấp trình tự được ghi nhận là luôn luôn khuyến khích các đối tượng có danh tính tham chiếu , sẽ không khôn ngoan khi cho rằng nó làm như vậy.

Tôi nghĩ khái niệm chính là bạn nên coi bất kỳ IEnumerable<T>bộ sưu tập nào là bất biến : bạn không nên sửa đổi các đối tượng từ nó, bạn nên tạo một bộ sưu tập mới với các đối tượng mới:

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

(Hoặc viết tương tự ngắn gọn hơn bằng cách sử dụng LINQ Select().)

Nếu bạn thực sự muốn sửa đổi các mục trong bộ sưu tập, không sử dụng IEnumerable<T>, sử dụng IList<T>(hoặc có thể IReadOnlyList<T>nếu bạn không muốn sửa đổi chính bộ sưu tập đó, chỉ các mục trong đó và bạn đang trên .Net 4.5):

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

Bằng cách này, nếu ai đó cố gắng sử dụng phương thức của bạn IEnumerable<T>, nó sẽ thất bại tại thời gian biên dịch.

Cá nhân tôi nghĩ rằng vấn đề được nhấn mạnh trong bài viết đó bắt nguồn từ việc lạm dụng IEnumerablegiao diện của nhiều nhà phát triển C # ngày nay. Nó dường như đã trở thành loại mặc định khi bạn yêu cầu một bộ sưu tập các đối tượng - nhưng có rất nhiều thông tin IEnumerableđơn giản là không cho bạn biết ... điều quan trọng: liệu nó có được thống nhất * hay không.

Nếu bạn thấy rằng bạn cần phải phát hiện xem một IEnumerablethực sự là một IEnumerablecái gì đó hay cái gì khác, sự trừu tượng đã bị rò rỉ và có lẽ bạn đang ở trong một tình huống mà loại tham số của bạn quá lỏng lẻo. Nếu bạn yêu cầu thêm thông tin mà IEnumerablemột mình không cung cấp, hãy làm rõ yêu cầu đó bằng cách chọn một trong các giao diện khác như ICollectionhoặc IList.

Chỉnh sửa cho các downvoters Vui lòng quay lại và đọc câu hỏi cẩn thận. OP đang yêu cầu một cách để đảm bảo rằng các IEnumerablephiên bản đã được cụ thể hóa trước khi được chuyển sang phương thức API của anh ấy. Câu trả lời của tôi giải quyết câu hỏi đó. Có một vấn đề rộng hơn liên quan đến cách sử dụng phù hợp IEnumerablevà chắc chắn những kỳ vọng về mã mà OP đã dán dựa trên sự hiểu lầm về vấn đề rộng hơn đó, nhưng OP không hỏi cách sử dụng chính xác IEnumerablehoặc cách làm việc với các loại không thay đổi . Thật không công bằng khi hạ thấp tôi vì đã không trả lời một câu hỏi không được đặt ra.

* Tôi sử dụng thuật ngữ reify, những người khác sử dụng stabilizehoặc materialize. Tôi không nghĩ rằng một quy ước chung đã được cộng đồng chấp nhận.