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);
    }
}


发表评论

电子邮件地址不会被公开。 必填项已用 * 标注

*

您可以使用这些 HTML 标签和属性: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

(Spamcheck Enabled)