C# IEnumerator with foreach loops, best design pattern?

I know similar questions have been asked before, but I've come to a dead end while trying to find the best design pattern I can use.

I am trying to make a class-library with a factory class that provides enumerators for different items via method calls. Note: Those items don't exist in a collection and can only be created knowing the previous one. (e.g. x(i) = x(i-1) + θ) Because of that I cannot implement those items as IEnumerable(s)

What I thought until now:

public static class AllItems {
    public sealed class ItemsEnumerator: IEnumerator<Item>{
       //those classes have non-public constructors
       .....
    }
    public static ItemsEnumerator GetItemsEnumerator() {
       return new ItemsEnumerator();
   }

    public sealed class OtherItemsEnumerator:IEnumerator<OtherItem>{
        ....
    }
    public static ItemsEnumerator GetOtherItemsEnumerator() {
       return new ItemsOtherEnumerator();
   }
}

this way i could do :

foreach(var item in AllItems.GetItemsEnumerator()){
   //do something with item
}

which won't work, because according to c# spec ItemsEnumerator doesn't have a GetEnumerator function(To be used in a foreach statement)

If I change it to this

public static class AllItems {
    public sealed class ItemsEnumerator: IEnumerator{
       .....
       public IEnumerator<Item> GetEnumerator() {
         return this;
       }
    }

    public static ItemsEnumerator GetItemsEnumerator() {
       return new ItemsEnumerator();
    } 
}

Is this a good design in general, or am I missing something here?

EDIT: Clarification on c# spec limitation