Sure, there are two.

{
 Dictionary<string, MyType> dict = new Dictionary<string, MyType>();

 ...

 foreach (string s in dict.Keys)
   ...

 foreach (MyType t in dict.Values)
   ...

}

Joanna

All of the framework collection classes implement IEnumerable (and
IEnumerable<T> for generic collections).  IEnumerable provides a simple
iterator-like in-order enumeration of the collection.

The exact type of the enumerator for a collection is generally a nested,
private class, so you never actually declare variables of those types.
Instead, you use the IEnumerable ( <T> ) interface type.

Using C++/CLI or C# (I don't know about VB.NET) you usually don't even
declare variables of type IEnumerable.  Rather, you make use of the built-in
language feature known as foreach.

foreach (T t in collection)
{
}

is syntactic sugar for:

IEnumerable<T> it = collection.GetEnumerator();
while (it.MoveNext())
{
   T t = it.Current;
   // ...
}

In the case of System.Collections.Generic.Dictionary, there are 3 possible
iterators:

Dictionary<K,V> dict = ...

dict.GetEnumerator() - returns
IEnumerable<System.Collections.Generic.KeyValuePair<K,V>>.  This is most
closely equivalent to std::map::iterator (which iterates over
std::pair<K,V>).

dict.Keys.GetEnumerator() - returns IEnumerable<K>.  This iterator
enumerates the keys in the dictionary.

dict.Values.GetEnumerator() - returns IEnumerable<V>.  This iterator
enumerates the values in the dictionary in the same order that the keys are
returned by dict.Keys.GetEnumerator().

-cd

There's the Keys property to return an enumeration of the keys, the
Values property to return an enumeration of the values, or just call
GetEnumerator() (or use foreach) to get an enumeration of KeyValuePair
items.