[英]Why is List<T>.Enumerator faster than my implementation?
由於各種大的性能優勢(在我的情況下),我發現自己處於一個我必須推出自己的動態數組實現的位置。 但是,在為我的版本創建一個枚舉器,並將效率與List使用的比較后,我有點困惑; List one比我的版本大約快30-40%,盡管它要復雜得多。
這是List枚舉器實現的重要部分:
public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
{
private List<T> list;
private int index;
private int version;
private T current;
internal Enumerator(List<T> list)
{
this.list = list;
this.index = 0;
this.version = list._version;
this.current = default(T);
return;
}
public bool MoveNext()
{
List<T> list;
list = this.list;
if (this.version != list._version)
{
goto Label_004A;
}
if (this.index >= list._size)
{
goto Label_004A;
}
this.current = list._items[this.index];
this.index += 1;
return 1;
Label_004A:
return this.MoveNextRare();
}
public T Current
{
get { return this.current; }
}
}
這是我的准系統版本:
internal struct DynamicArrayEnumerator<T> : IEnumerator<T> where T : class
{
private readonly T[] internalArray;
private readonly int lastIndex;
private int currentIndex;
internal DynamicArrayEnumerator(DynamicArray<T> dynamicArray)
{
internalArray = dynamicArray.internalArray;
lastIndex = internalArray.Length - 1;
currentIndex = -1;
}
public T Current
{
get { return internalArray[currentIndex]; }
}
public bool MoveNext()
{
return (++currentIndex <= lastIndex);
}
}
我知道這是微優化,但我真的很有興趣理解為什么List枚舉器比我的快得多。 有任何想法嗎? 謝謝!
編輯:按要求; DynamicArray類(相關部分):枚舉器是一個內部類。
public struct DynamicArray<T> : IEnumerable<T> where T : class
{
private T[] internalArray;
private int itemCount;
internal T[] Data
{
get { return internalArray; }
}
public int Count
{
get { return itemCount; }
}
public DynamicArray(int count)
{
this.internalArray = new T[count];
this.itemCount = 0;
}
public IEnumerator<T> GetEnumerator()
{
return new DynamicArrayEnumerator<T>(this);
}
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
}
至於我如何測試:
List<BaseClass> list = new List<BaseClass>(1000000);
DynamicArray<BaseClass> dynamicArray = new DynamicArray<BaseClass>(1000000);
// Code for filling with data omitted.
int numberOfRuns = 0;
float p1Total = 0;
float p2Total = 0;
while (numberOfRuns < 100)
{
PerformanceAnalyzer p1 = new PerformanceAnalyzer(() =>
{
int u = 0;
foreach (BaseClass b in list)
{
if (b.B > 100) // Some trivial task
u++;
}
});
p1.ExecuteAndClock();
p1Total += p1.TotalElapsedTicks;
PerformanceAnalyzer p2 = new PerformanceAnalyzer(() =>
{
int u = 0;
foreach (BaseClass b in dynamicArray)
{
if (b.B > 100) // Some trivial task
u++;
}
});
p2.ExecuteAndClock();
p2Total += p2.TotalElapsedTicks;
numberOfRuns++;
}
Console.WriteLine("List enumeration: " + p1Total / totalRuns + "\n");
Console.WriteLine("Dynamic array enumeration: " + p2Total / totalRuns + "\n");
PerformanceAnalyzer類基本上啟動一個秒表,執行提供的Action委托,然后停止秒表。
編輯2(對Ryan Gates的快速回答):有幾個原因我想要自己動手,最重要的是我需要一個非常快的RemoveAt(int index)方法。
由於我不必擔心在我的特定情況下列表元素的順序,我可以避免.Net內置列表的方式:
public void RemoveAt(int index)
{
T local;
if (index < this._size)
{
goto Label_000E;
}
ThrowHelper.ThrowArgumentOutOfRangeException();
Label_000E:
this._size -= 1;
if (index >= this._size)
{
goto Label_0042;
}
Array.Copy(this._items, index + 1, this._items, index, this._size - index);
Label_0042:
this._items[this._size] = default(T);
this._version += 1;
return;
}
而是使用以下內容:
public void RemoveAt(int index)
{
// overwrites the element at the specified index with the last element in the array and decreases the item count.
internalArray[index] = internalArray[itemCount];
itemCount--;
}
在我的情況下可以節省大量的時間,如果說長列表中的前1000個元素必須通過索引刪除。
好的,除了基准測試問題之外,以下是如何使您的DynamicArray
類更像List<T>
:
public DynamicArrayEnumerator<T> GetEnumerator()
{
return new DynamicArrayEnumerator<T>(this);
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
現在, 知道它使用動態數組的代碼可以使用DynamicArrayEnumerator<T>
進行迭代而無需任何裝箱,也無需虛擬分派 。 這正是List<T>
所做的。 當類型以自定義方式實現模式時,編譯器會注意到,並將使用所涉及的類型而不是接口。
使用您當前的代碼,您將無法從創建struct
獲益 - 因為您在GetEnumerator()
中將其裝箱。
嘗試上述更改並修復基准測試以延長工作時間。 我希望看到一個很大的不同。
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.