Is there an IEnumerable implementation that only iterates over it's source (e.g. LINQ) once?

Provided items is the result of a LINQ expression:

var items = from item in ItemsSource.RetrieveItems()
            where ...

Suppose generation of each item takes some non-negligeble time.

Two modes of operation are possible:

1. Using foreach would allow to start working with items in the beginning of the collection much sooner than whose in the end become available. However if we wanted to later process the same collection again, we'll have to copy save it:

   var storedItems = new List<Item>();
   foreach(var item in items)
   {
       Process(item);
       storedItems.Add(item);
   }
   
   // Later
   foreach(var item in storedItems)
   {
       ProcessMore(item);
   }
   

   Because if we'd just made foreach(... in items) then ItemsSource.RetrieveItems() would get called again.

2. We could use .ToList() right upfront, but that would force us wait for the last item to be retrieved before we could start processing the first one.

Question: Is there an IEnumerable implementation that would iterate first time like regular LINQ query result, but would materialize in process so that second foreach would iterate over stored values?