Как раз тогда, когда stackoverflow является честным и разумным?

Ответ 1

Как упоминалось в другом сообщении, которое вы связали, бесконечное перечисление имеет смысл перечислить С# и есть огромное количество примеров реального мира, где люди пишут перечисления, которые просто никогда не заканчиваются (первое, что отвлекает меня является генератором случайных чисел).

Итак, у вас есть частный случай в вашей математической задаче, где вам нужно определить специальное значение (бесконечное количество точек пересечения). Обычно это то, где я использую простые статические константы. Просто определите некоторую статическую константу IEnumerable и протестируйте ее, чтобы выяснить, был ли ваш алгоритм "бесконечным числом пересечений" в качестве результата.

Более конкретный ответ на ваш текущий вопрос: НЕ КОГДА-ЛИБО НИКОГДА не вызывать переполнение реального стека. Это самая неприятная вещь, которую вы можете сделать для пользователей вашего кода. Его невозможно поймать и немедленно прекратит ваш процесс (возможно, единственным исключением является то, что вы работаете внутри подключенного отладчика инструментов).

Если вообще, я бы использовал NotSupportedException, который используется в других местах, чтобы сигнализировать, что какой-то класс не поддерживает функцию (например, ICollection может бросить это в Remove(), если они доступны только для чтения).

Ответ 2

public IEnumerator<T> GetEnumerator()
{
    while (true)
        yield return default(T);
}

Это создаст бесконечный перечислитель - foreach на нем никогда не закончится и будет продолжать выдавать значение по умолчанию.

Обратите внимание, что вы не сможете определить IsInfinity() способ, которым вы написали код. Это потому, что new Infinity().Where(o => o == /*do any kind of comparison*/) будет по-прежнему бесконечным, но будет иметь другой тип.

Ответ 3

Если я правильно понимаю, бесконечное - это путаное слово здесь. Я думаю, вам нужна монада, которая либо перечислима, либо нет. Но пусть навсегда останется безграничным.

Я не могу придумать хороший способ реализации этого в С#. Все пути, которые это может быть реализовано, не интегрируются с генераторами С#.

С С# generator вы можете испускать только допустимые значения; поэтому нет способа указать, что это бесконечное перечислимое. Мне не нравится идея бросать исключения из генератора, чтобы указать, что она бесконечна; потому что, чтобы проверить, что это бесконечно, вам придется каждый раз пытаться поймать.

Если вам не нужно поддерживать генераторы, я вижу следующие параметры:

• Внедрение счетного числа:

  public class InfiniteEnumerable<T>: IEnumerable<T> {
      private static InfiniteEnumerable<T> val;
  
      public static InfiniteEnumerable<T> Value {
          get {
              return val;
          }
      }
  
      public IEnumerator<T> GetEnumerator() {
          throw new InvalidOperationException(
              "This enumerable cannot be enumerated");
      }
  
      IEnumerator IEnumerable.GetEnumerator() {
          throw new InvalidOperationException(
               "This enumerable cannot be enumerated");
      }
  }
  

  Использование образца:

  IEnumerable<int> enumerable=GetEnumerable();
  
  if(enumerable==InfiniteEnumerable<int>.Value) {
      // This is 'infinite' enumerable.
  }
  else {
      // enumerate it here.
  }
  

• Внедрить Infinitable<T> wrapper:

  public class Infinitable<T>: IEnumerable<T> {
      private IEnumerable<T> enumerable;
      private bool isInfinite;
  
      public Infinitable(IEnumerable<T> enumerable) {
          this.enumerable=enumerable;
          this.isInfinite=false;
      }
  
      public Infinitable() {
          this.isInfinite=true;
      }
  
      public bool IsInfinite {
          get {
              return isInfinite;
          }
      }
  
      public IEnumerator<T> GetEnumerator() {
          if(isInfinite) {
              throw new InvalidOperationException(
                  "The enumerable cannot be enumerated");
          }
  
          return this.enumerable.GetEnumerator();
      }
  
      IEnumerator IEnumerable.GetEnumerator() {
          if(isInfinite) {
              throw new InvalidOperationException(
                   "The enumerable cannot be enumerated");
          }
  
          return this.enumerable.GetEnumerator();
      }
  }
  

  Использование образца:

  Infinitable<int> enumerable=GetEnumerable();
  
  if(enumerable.IsInfinite) {
      // This is 'infinite' enumerable.
  }
  else {
      // enumerate it here.
      foreach(var i in enumerable) {
      }
  }
  

Ответ 4

Бесконечные последовательности могут быть совершенно итерабельными/перечислимыми. Естественные числа перечислимы, а также являются рациональными числами или цифрами PI. Бесконечность - это противоположность конечному, неперечислимому.

Варианты, которые вы предоставили, не представляют бесконечные последовательности. Существует бесконечно много разных бесконечных последовательностей, и вы можете видеть, что они различаются, итерации через них. С другой стороны, ваша идея состоит в том, чтобы иметь один синглтон, который идет вразрез с этим разнообразием.

Если у вас есть что-то, что невозможно перечислить (например, набор действительных чисел), вы просто не должны определять его как IEnumerable, поскольку он нарушает контракт. Если вы хотите различить конечные и бесконечные перечислимые последовательности, просто создайте новый интерфейс IInfiniteEnumerable : IEnumerable и отметьте с ним бесконечные последовательности.

Интерфейс, который отмечает бесконечные последовательности

public interface IInfiniteEnumerable<T> : IEnumerable<T> {
}

Обертка для преобразования существующих IEnumerable<T> в IInfiniteEnumerable<T> (IEnumerable легко создается с синтаксисом С# yield, но нам нужно преобразовать их в IInfiniteEnumerable)

public class InfiniteEnumerableWrapper<T> : IInfiniteEnumerable<T> {
    IEnumerable<T> _enumerable;

    public InfiniteEnumerableWrapper(IEnumerable<T> enumerable) {
        _enumerable = enumerable;
    }

    public IEnumerator<T> GetEnumerator() {
        return _enumerable.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return _enumerable.GetEnumerator();
    }
}

Некоторые процедуры, поддерживающие бесконечность (например, вычисление длины последовательности)

//TryGetCount() returns null if the sequence is infinite
public static class EnumerableExtensions {
    public static int? TryGetCount<T>(this IEnumerable<T> sequence) {
        if (sequence is IInfiniteEnumerable<T>) {
            return null;
        } else {
            return sequence.Count();
        }
    }
}

Два примера последовательностей - последовательность конечного диапазона и бесконечная последовательность Фибоначчи.

public class Sequences {
    public static IEnumerable<int> GetIntegerRange(int start, int count) {
        return Enumerable.Range(start, count);
    }

    public static IInfiniteEnumerable<int> GetFibonacciSequence() {
        return new InfiniteEnumerableWrapper<int>(GetFibonacciSequenceInternal());
    }

    static IEnumerable<int> GetFibonacciSequenceInternal() {
        var p = 0;
        var q = 1;
        while (true) {
            yield return p;
            var newQ = p + q;
            p = q;
            q = newQ;
        }
    }
}

Тестовое приложение, которое генерирует случайные последовательности и пытается рассчитать их длины.

public class TestApp {
    public static void Main() {
        for (int i = 0; i < 20; i++) {
            IEnumerable<int> sequence = GetRandomSequence();
            Console.WriteLine(sequence.TryGetCount() ?? double.PositiveInfinity);
        }
        Console.ReadLine();
    }

    static Random _rng = new Random();
    //Randomly generates an finite or infinite sequence
    public static IEnumerable<int> GetRandomSequence() {
        int random = _rng.Next(5) * 10;
        if (random == 0) {
            return Sequences.GetFibonacciSequence();
        } else {
            return Sequences.GetIntegerRange(0, random);
        }
    }
}

Программа выводит что-то вроде этого:

20
40
20
10
20
10
20
Infinity
40
30
40
Infinity
Infinity
40
40
30
20
30
40
30