foreach (string s in myStringArray)
{
  ...
}

foreach (string s in myStringList.Reverse)
{
  ...
}

public static IEnumerable<int> Power(int number, int exponent)
{
   int counter = 0;
   int result = 1;
   while (counter++ < exponent)
   {
      result = result * number;
      yield return result;
   }
}

foreach (int i in Power(2, 8))
{
   Console.WriteLine(i);
}

IEnumerator<int> it = Power(2, 8).GetEnumerator();
while (it.MoveNext())
{
   Console.WriteLine(it.Current);
}

public static IEnumerable<?> MyScript()
{
   Console.WriteLine("Script begin");
   yield return ?;
   Console.WriteLine("Script mid");
   yield return ?;
   Console.WriteLine("Script end");
}

public abstract class ScriptContinueCondition
{
   public abstract bool IsFulfulled();
}

public class Wait : ScriptContinueCondition
{
   protected   DateTime   beginTime;
   protected   TimeSpan   time;

   public Wait(TimeSpan time)
   {
      this.beginTime = DateTime.Now;
      this.time = time;
   }

   public override bool IsFulfulled()
   {
      if (DateTime.Now - this.beginTime >= time) return true;
      return false;
   }
}

// This is our script iterator, normally would be saved locally somewhere
IEnumerator<ScriptContinueCondition> scriptPos = MyScript().GetEnumerator();

// This is our simulated game loop
while (true)
{
   // Check, if we can proceed
   if (scriptPos.Current == null || scriptPos.Current.IsFulfulled())
   {
      // Process a script block
      scriptPos.MoveNext();
   }

   // Print something to look busy.
   Console.WriteLine(".");
   // This simulates we're doing something else here
   System.Threading.Thread.Sleep(100);
}

public static IEnumerable<ScriptContinueCondition> MyScript()
{
   Console.WriteLine("Script begin");
   yield return new Wait(TimeSpan.FromMilliseconds(1000));
   Console.WriteLine("Script mid");
   yield return new Wait(TimeSpan.FromMilliseconds(1000));
   Console.WriteLine("Script end");
}

class ObjectA : SteObject {...}; class ObjectADesc : SteObjectDesc {...}

class ObjectB : SteObject
{
  List<ObjectA> objRefList;  // Nur Referenz, da desc. Objekte sich nicht ebenfalls in ObjectBDesc befinden
  ObjectA[] nestedObjects;  // Echte, nested SteObjects, da auch ObjectADesc[] in ObjectBDesc enthalten.
}

class ObjectBDesc : SteObjectDesc
{
  List<string> objRefList;
  ObjectADesc[] nestedObjects;
}