Обнаружение множества «государственных машин»

Я только что прочитал интересную статью под названием Получение слишком мило с C # yield return

Это заставило меня задуматься о том, как лучше всего определить, является ли 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, что и в прошлый раз. То, генерируется ли код последовательности автоматически или нет, является ортогональным к вопросу о том, имеют ли перечисленные объекты ссылочную идентичность или нет. Эти два свойства - автоматическая генерация и ссылочная идентичность - на самом деле не имеют ничего общего друг с другом. Статья, на которую вы ссылаетесь, несколько их объединяет.

Если поставщик последовательности не задокументирован как всегда предлагающий объекты, имеющие ссылочную идентичность , неразумно полагать, что это так.

Я думаю, что ключевой концепцией является то, что вы должны рассматривать любую 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действительно ли объект является a IEnumerableили чем-то еще, абстракция просочилась, и вы, вероятно, находитесь в ситуации, когда ваш тип параметра немного слишком свободный. Если вам требуется дополнительная информация, которая IEnumerableсама по себе не предоставлена, сделайте это требование явным, выбрав один из других интерфейсов, таких как ICollectionили IList.

Редактировать для downvoters Пожалуйста, вернитесь и внимательно прочитайте вопрос. ОП запрашивает способ обеспечения того, чтобы IEnumerableэкземпляры были материализованы перед передачей его методу API. Мой ответ на этот вопрос. Существует более широкая проблема, касающаяся правильного способа использования IEnumerable, и, конечно, ожидания кода, вставленного OP, основаны на неправильном понимании этой более широкой проблемы, но OP не спрашивал, как правильно использовать IEnumerableили как работать с неизменяемыми типами. , Нечестно опровергать меня за то, что я не отвечаю на вопрос, который не был поставлен.

* Я использую термин reify, другие используют stabilizeили materialize. Я не думаю, что сообщество уже приняло общую конвенцию.