关于for和foreach，兼顾效率与安全
对于数组的访问，是应该使用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[i]);
}
}
以上建议，对于在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[i];
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);
}
}
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[i]); }}以上建议，对于在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[i]; 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); }}
