对于数组的访问，是应该使用for的方式的，因为这样性能更高。以下代码是恰当的。 Object[] objArray = ...;
int objArrayLength = objArray.Length;
for (int i = 0; i < objArrayLength; ++i)
{
// do something ...
}
String str = ...;
int strLength = str.Length;
for (int i = 0; i < strLength; ++i)
{
// do something ...
}
对ArrayList这样的可使用下标进行随机访问的数据结构，使用下标访问，要比foreach的方式进行顺序访问，速度要快一些。foreach这样 写法，使用的过程产生一个额外的对象Enumerator，而且每次访问需要更多的操作，降低性能。下面的两种写法编译出的代码是一样的：
第一种写法：
IList list = new ArrayList();
IEnumerator iter = list.GetEnumerator();
try
{
while (iter.MoveNext())
{
Object obj = iter.Current;
//do something ...
}
}
finally
{
IDisposable disposableObj = iter as IDisposable;
if (disposableObj != null)
{
disposableObj.Dispose();
}
}
第二种写法： IList list = new ArrayList();
foreach (Object obj in list)
{
//do something ...
}
对比这两种写法，第一种写法非常罗嗦，所以C#引入了foreach的语法。通过观察第一种写法，foreach是通过GetEnumerator获得一 个IEnumerator对象，通过IEnumerator对象执行MoveNext()方法和获取Current属性进行遍历的。
我们再通过Reflector工具，查看mscorlib.dll中System.Collection.ArrayList的实现： //为了简单起见，我只列出ArrayList的Add、Clear、GetEnumerator的代码
public class ArrayList
{
//这是一个版本标识，ArrayList对象，每做一个修改操作，_version都会加1
private int _version;
public virtual int Add(object value)
{
int num1;
if (this._size == this._items.Length)
{
this.EnsureCapacity((this._size + 1));
}
this._items[this._size] = value;
++this._version; //注意此处
this._size = ((num1 = this._size) + 1);
return num1;
}
public virtual void Clear()
{
Array.Clear(this._items, 0, this._size);
this._size = 0;
++this._version; //注意此处
}
//每次调用GetEnumerator方法，都会构造一个FastArrayListEnumerator
//或者ArrayListEnumeratorSimple对象。
public virtual IEnumerator GetEnumerator()
{
if (base.GetType() == typeof(ArrayList))
{
return new ArrayList.FastArrayListEnumerator(this);
}
return new ArrayList.ArrayListEnumeratorSimple(this);
}
}
通过上述代码可以看到，ArrayList是通过_version成员变量作版本标识的，每次执行Add、Clear等修改ArrayList内容的操 作，都会将版本号加1，而每次调用GetEnumerator方法，都会构造一个FastArrayListEnumerator或者 ArrayListEnumeratorSimple对象。我们再看FastArrayListEnumerator的实现： class FastArrayListEnumerator
{
private int version;
internal FastArrayListEnumerator(ArrayList list)
{
this.list = list;
this.index = -1;
//获取构建FastArrayListEnumerator对象时ArrayList的版本号
this.version = list._version;
this.lastIndex = (list._size - 1);
}
public bool MoveNext()
{
int num1;
//比较ArrayList当前的版本号，
//是否和构建FastArrayListEnumerator对象时的版本号一致
//如果不一致，则抛出异常。
if (this.version != this.list._version)
{
throw new InvalidOperationException(
Environment.GetResourceString("InvalidOperation_EnumFailedVersion"
);
}
//... ...
}
}
FastArrayListEnumerator对象构建时，当时时ArrayList的版本号。当执行MoveNext()操作时，检查 ArrayList当前的版本号是否和FastArrayListEnumerator对象构建时的版本号一致，如果不一致就会抛出异常。
由于Enumerator中，做了版本检查处理的工作，所以使用foreach是线程安全，而使用for则不时。为什么呢？如果在使用foreach遍历 对象的过程中，其他线程修改了List的内容，例如添加或者删除，就会出现不可知的错误，而使用foreach则能够正确抛出错误信息。
综上所述，结论如下：
使用for，更高效率。
使用foreach，更安全。
那么如何选择呢？我的建议是，在一些全局的，多线程可以访问的数据结构对象，使用foreach。而对本地变量，则使用for，效率和安全兼顾！例如： public void F1(IList globalList)
{
IList waitForDeleteList = new ArrayList();
//全局变量，使用foreach，保证线程
foreach (Object item in globalList)
{
if (condition)
{
waitForDeleteList.Add(item);
}
}
//本地变量使用for，保证效率
int waitForDeleteListCount = waitForDeleteList.Count;
for (int i = 0; i < waitForDeleteListCount; ++i)
{
globalList.Remove(waitForDeleteList);
}
}
以上建议，对于在Java环境下也使用，我阅读过JDK 1.4的java.util.ArrayList的实现，.NET Framework的实现和JDK的实现，几乎是一样的，是否抄袭，见仁见智。上述的C#代码在Java环境中应为： public void f1(List globalList) {
List waitForDeleteList = new ArrayList();
//全局变量，使用Iterator遍历，保证线程
Iterator iter = globalList.iterator();
while (iter.hasNext()) {
Object item = iter.next();
if (condition) {
waitForDeleteList.add(item);
}
}
//本地变量使用for，保证效率
int waitForDeleteListCount = waitForDeleteList.size();
for (int i = 0; i < waitForDeleteListCount; ++i) {
globalList.remove(waitForDeleteList.get(i));
}
}
注意，以上代码并不是做该项工作的最优算法，如果需要更高的效率，修改如下：
C#版本
public void F1(IList globalList)
{
bool condition = true;
IList waitForDeleteList = new ArrayList();
//全局变量，使用foreach，保证线程
int itemIndex = 0;
foreach (Object item in globalList)
{
if (condition)
{
waitForDeleteList.Add(index);
}
++itemIndex;
}
//本地变量使用for，保证效率
int waitForDeleteListCount = waitForDeleteList.Count;
for (int i = waitForDeleteListCount - 1; i >= 0; --i)
{
index = (int) waitForDeleteList;
globalList.RemoveAt(itemIndex);
}
}
Java版本：
public void f1(List globalList) {
List waitForDeleteList = new ArrayList();
//全局变量，使用Iterator遍历，保证线程
Iterator iter = globalList.iterator();
int index = 0;
while (iter.hasNext()) {
Object item = iter.next();
if (condition) {
waitForDeleteList.add(new Integer(index));
}
++index;
}
//本地变量使用for，保证效率
int waitForDeleteListCount = waitForDeleteList.size();
for (int i = waitForDeleteListCount - 1; i >= 0; --i) {
index = ((Integer) waitForDeleteList.get(i)).intValue();
globalList.remove(index);
}
}
呵呵，你说的意思我明白，不过有一些东西我还是觉得不能够完全认同你的。
1、线程安全。
这里其实不涉及线程安全，所谓线程安全在foreach里面可以部分的保证，但是不能够完全保证。SyncRoot才是保证线程安全的东 西，_version所保护的并不是线程安全，而是类似iterator模式里面的“安全遍历”问题。.NET Framework在这里有点“偷懒”并不能够保证“安全遍历”，如果在遍历期间修改了元素的内容，则会引发异常。既然是引发异常，那就不是“XX安全” 或者“安全XX”，因为他认为这是一种异常情况，而不是“安全”情况。
你可以分析一下SyncRoot属性的行为，应该可以看到有一个什么特殊的类型，用于“线程安全”操作的。（这个是我估计的，因为在绝大多数的集合类型里 面都会采用一个内部嵌套的类来提供线程安全问题。不过在.NET 2.0里面的Generic集合类型里面不提供这样的操作了，也就是不提供SyncRoot了，因为实际上还是有可能线程不安全的。）在这里面你会看到实 际上是通过lock（或者类似的其它东西，目前我没有见到除了lock之外的其他东西，但不排除）来达到线程安全的，实际上并不会引发任何的 exception。
试想一下，如果说一个操作能够引发异常，那么这个操作无论如何都不能够说是“安全”的操作。如果你的程序在foreach外面没有try...catch，甚至会让你的程序崩溃掉，试问，这样是安全的吗？不是吧？我宁愿认为for是“安全的”，尽管他不完全正确。
实际上如果你在for里面进行add/insert/remove操作，是完全可以判断应该怎么修改index的值，以达到安全遍历的效果。（例如对于 add，index完全不需要修改；对于insert，如果insert_index < index 那么 index++ 否则不处理；remove和insert一样，除了把++换成--）
2、另外，我在你那篇文章里面回复的内容，实际上不会有安全问题，因为我把它copy出来了再进行操作。或者说，遍历的是keys和values数组，修改的是ht哈希表，对哈希表的修改不会影响keys和values，所以完全不会构成冲突。
不知道我说的是否有理呢？
你的回复中，对于安全的描述，你说的也有一定道理，既然引发了异常就不是安全了。
其实我想表达的安全，就是你所说的安全遍历。一般编写多线程程序时，使用for都要很小心，因为for无法保证安全遍历，一旦出错，谁也不知道为什么，这种错误，可能极难被人发现。
记得以前刚学多线程编程的时候，在一本Java关于多线程编程的书上，就介绍，多线程慎用for，常识呀。
你对Dictionay数据结构的遍历方式，我对此还是持保留态度。我认为，这种方式，数据量小，不一定快，大数据量肯定慢，如果中途有break退出，就更不值得了，因此不推荐使用。