Sequence generators not only for potatoes but also for apples and oranges
A slightly different approach is to avoid the sublclassing and instead feed the generic DelaySequence class with a generator function. It makes it more flexible.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace CR146856
{
  public class MyDelaySequence&lt;T&gt; : IEnumerable&lt;T&gt;
  {
    Func&lt;IEnumerable&lt;T&gt;&gt; m_generator;
    int m_count = 0;

    /// &lt;summary&gt;
    /// A contructor for a plain sequence of regular delays
    /// &lt;/summary&gt;
    /// &lt;param name="count"&gt;Number of retries.&lt;/param&gt;
    /// &lt;param name="delay"&gt;The delay after each retry.&lt;/param&gt;
    public MyDelaySequence(int count, T delay)
    {
      m_count = count;
      m_generator = () =&gt;
      {
        return Enumerable.Range(1, count).Select(i =&gt; delay);
      };
    }

    /// &lt;summary&gt;
    /// Constructor for a custom delay generator.
    /// &lt;/summary&gt;
    /// &lt;param name="count"&gt;Number of retries.&lt;/param&gt;
    /// &lt;param name="generator"&gt;A custom generator of delays between retries.&lt;/param&gt;
    public MyDelaySequence(int count, Func&lt;IEnumerable&lt;T&gt;&gt; generator)
    {
      m_count = count;
      m_generator = generator;
    }

    public IEnumerator&lt;T&gt; GetEnumerator()
    {
      return m_generator().Take(m_count).GetEnumerator();
    }

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

  class Program
  {
    static IEnumerable&lt;int&gt; GeometricDelayGenerator()
    {
      int delay = 1000;
      while (true)
      {
        yield return delay;
        delay += delay;
      }
    }

    static IEnumerable&lt;int&gt; FibonacciIntDelayGenerator()
    {
      int first = 1000;

      yield return first;
      yield return first;

      int second = first + 3000;
      yield return second;


      while (true)
      {
        yield return first + second;
        int tmp = first;
        first = second;
        second = first + tmp;
      }
    }

    static IEnumerable&lt;TimeSpan&gt; FibonacciTimeSpanDelayGenerator()
    {
      TimeSpan first = TimeSpan.FromSeconds(1);

      yield return first;
      yield return first;

      TimeSpan second = first + TimeSpan.FromSeconds(3);
      yield return second;


      while (true)
      {
        yield return first + second;
        TimeSpan tmp = first;
        first = second;
        second = first + tmp;
      }
    }

    static void Main(string[] args)
    {
      try
      {
        TimeSpan seqDelay = TimeSpan.FromSeconds(1);
        int count = 7;

        foreach (var ts in new MyDelaySequence&lt;TimeSpan&gt;(count, FibonacciTimeSpanDelayGenerator))
        {
          Console.WriteLine(ts);
        }
      }
      catch (Exception ex)
      {
        Console.WriteLine($"ERROR: {ex.Message}");
      }

      Console.WriteLine("END");
      Console.ReadLine();
    }
  }
}


That said I tend to think you overdo a rather simple construct:

    foreach (var delay in FibonacciIntDelayGenerator().Take(count))
    {
      Console.WriteLine($"If service not responding wait in {delay} ms and retry.");
    }


EDIT:

In case of a reusable library of functions I would do it the static way:

  public static class MyDelayGenerators
  {
    public static IEnumerable&lt;T&gt; DelayGenerator&lt;T&gt;(int retries, T initialDelay, Func&lt;T, T&gt; offsetFunc)
    {
      T delay = initialDelay;
      for (int i = 0; i &lt; retries; i++)
      {
        yield return delay;
        delay = offsetFunc(delay);
      }
    }

    public static IEnumerable&lt;T&gt; GeometricDelayGenerator&lt;T&gt;(int retries, T initialDelay, Func&lt;T, T&gt; sum)
    {
      return DelayGenerator(retries, initialDelay, sum);
    }

    public static IEnumerable&lt;int&gt; GeometricDelayGenerator(int retries, int initialDelay)
    {
      return DelayGenerator(retries, initialDelay, (d) =&gt; d + d);
    }

    public static IEnumerable&lt;TimeSpan&gt; GeometricDelayGenerator(int retries, TimeSpan initialDelay)
    {
      return DelayGenerator(retries, initialDelay, (d) =&gt; d + d);
    }

    public static IEnumerable&lt;int&gt; RegularDelayGenerator(int retries, int delay)
    {
      for (int i = 0; i &lt; retries; i++)
      {
        yield return delay;
      }
    }

    public static IEnumerable&lt;TimeSpan&gt; RegularDelayGenerator(int retries, TimeSpan delay)
    {
      for (int i = 0; i &lt; retries; i++)
      {
        yield return delay;
      }
    }

    public static IEnumerable&lt;T&gt; FibonacciDelayGenerator&lt;T&gt;(int retries, T first, T firstOffset, Func&lt;T, T, T&gt; sum)
    {
      yield return first;
      yield return first;

      T second = sum(first, firstOffset);
      yield return second;

      retries -= 3;
      for (int i = 0; i &lt; retries; i++)
      {
        T tmp = sum(first, second);
        yield return tmp;
        first = second;
        second = tmp;
      }
    }

    public static IEnumerable&lt;int&gt; FibonacciDelayGenerator(int retries, int first = 1000, int firstOffset = 1000)
    {
      return FibonacciDelayGenerator(retries, first, firstOffset, (f, s) =&gt;
      {
        int tmp = f;
        f = s;
        s = f + tmp;
        return s;
      });
    }

    public static IEnumerable&lt;TimeSpan&gt; FibonacciDelayGenerator(int retries, TimeSpan first, TimeSpan firstOffset)
    {
      return FibonacciDelayGenerator(retries, first, firstOffset, (f, s) =&gt;
      {
        TimeSpan tmp = f;
        f = s;
        s = f + tmp;
        return s;
      });
    }
  }


It has a number of predefined functions and a set of generic as well to be use on the fly.