より速い列挙：配列の列挙を利用する

Question

したがって、内部に配列を持つクラスがあります。現在、クラスの項目を列挙するための私の戦略は、コードforeach (item x in classInstance.InsideArray)を使用することです。私はむしろforeach (item x in classInstance)を使い、配列をプライベートにしたいと思います。私の主な関心事は、私は本当に遅いものを避ける必要があるということです。配列は多くヒットします（数百のアイテムがあります）。この配列を列挙することは安価であることが重要です。 1つの考えは、クラスにIEnumerable<item>を実装させることでしたが、InsideArray.getEnumerator()は私に非汎用の列挙子を与えます。私はまた、IEnumerableインターフェイスの実装を試みました。これは働いたが、おそらくボクシングのために非常に遅かった。

パフォーマンスヒットなしにクラス自体を列挙できる方法はありますか？

ノーマルコード：

調整、はるかに遅いコード：

//Class 
public class Foo : IEnumerable { 
    //Stuff 
    private Item[,] InsideArray; 
    System.Collections.IEnumerator System.Collections.IEnumerable GetEnumerator() 
    { 
     return InsideArray.GetEnumerator(); 
    } 
} 

//Iteration. Shows up all over the place 
foreach (Item x in classInstance) 
{ 
    //doStuff 
} 

注：非ジェネリックイテレータの実装を追加することができて、私の遅いソリューションよりも高速ですが、それはまだちょうど直接配列を使用するより悪いです。私は何とかC＃に "ちょっと、このオブジェクトを反復するように要求すると、それは配列と同じ速さで繰り返すように言いますが、どういうことかはっきりとは分かりません..."と答える方法があることを期待していましたこれまで。クラスにインデクサを追加する方法について

Answer 1

方法：

public MyInsideArrayType this[int index] 
{ 
    get{return this.insideArray[index]; 
} 

そして、あなたは本当にforeachの機能が必要な場合：

public IEnumerable<MyInsideArrayType> GetEnumerator() 
{ 
    for(int i = 0; i<this.insideArray.Count;i++) 
    { 
     yield return this[i]; 
    } 
} 

Answer 2

はGetEnumerator()を呼び出す前にIEnumerable<item>にあなたの配列をキャストして、あなたはジェネリックを取得しますIEnumerator。たとえば：

string[] names = { "Jon", "Marc" }; 
IEnumerator<string> enumerable = ((IEnumerable<string>)names).GetEnumerator(); 

これはよくまだforeachと直接配列を列挙するよりも少し遅くなることがあります（C＃コンパイラは、別の方法でん）が、少なくとも、あなたはある意味では他の何かを持っていません。

編集：

他の試みではインデクサーが使用されています。

代替で開始する2次元配列を使用しないようにしようとするだろう：私はそれがどんな速いだろうとは思わないが、あなたは、このアプローチを試みることができます。それは絶対的な要件ですか？ 1つのアレイを作成した後、どれくらいの頻度で反復していますか？反復を安くするために、作成時に少しヒットする価値があります。

EDIT：反復子を呼び出し元に戻すのではなく、壁を少し離れたもう1つの提案です。呼び出し元に代理人を使用して各アイテムの処理方法を教えてください。

public void ForEachItem(Action action) 
{ 
    foreach (Item item in items) 
    { 
     action(item); 
    } 
} 

欠点が：

• あなたは、各アクセスのデリゲート呼び出しのペナルティを被ります。
• （例外をスローする以外の方法では）ループから抜け出すのは難しいです。このアプローチにはさまざまな方法がありますが、私たちがそれに来るときにその橋を渡りましょう。
• デリゲートに精通していない開発者は、少し混乱するかもしれません。

Answer 3

すべての形式の反復は安価です。この日と年齢の誰かが何とか高価なイテレーターを書いて公開すると、彼らは（正しい）ステークに燃えてしまうでしょう。

早すぎる最適化は悪です。

乾杯。キース。

Answer 4

オーダーメイドのイテレータは（はとして知られているタイプを返すようにを編集した）、それは速くなるかもしれない：

Basic: 2468ms - -2049509440 
Bespoke: 1087ms - -2049509440 

（あなたがfooのGetEnumeratorメソッドとして直接ArrayIteratorを使用します - 本質的ArrayEnumerator.GetEnumeratorからコードをコピーし、自分のポイントは、コードで

）型指定のイテレータは、インタフェースよりも高速であることを示すことである。

using System; 
using System.Collections; 
using System.Collections.Generic; 
using System.Diagnostics; 

class Foo 
{ 
    public struct ArrayIterator<T> : IEnumerator<T> 
    { 
     private int x, y; 
     private readonly int width, height; 
     private T[,] data; 
     public ArrayIterator(T[,] data) 
     { 
      this.data = data; 
      this.width = data.GetLength(0); 
      this.height = data.GetLength(1); 
      x = y = 0; 
     } 
     public void Dispose() { data = null; } 
     public bool MoveNext() 
     { 
      if (++x >= width) 
      { 
       x = 0; 
       y++; 
      } 
      return y < height; 
     } 
     public void Reset() { x = y = 0; } 
     public T Current { get { return data[x, y]; } } 
     object IEnumerator.Current { get { return data[x, y]; } } 
    } 
    public sealed class ArrayEnumerator<T> : IEnumerable<T> 
    { 
     private readonly T[,] arr; 
     public ArrayEnumerator(T[,] arr) { this.arr = arr; } 

     public ArrayIterator<T> GetEnumerator() 
     { 
      return new ArrayIterator<T>(arr); 
     } 

     System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() 
     { 
      return GetEnumerator(); 
     } 
     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
     { 
      return GetEnumerator(); 
     } 

    } 
    public int[,] data; 

    public IEnumerable<int> Basic() 
    { 
     foreach (int i in data) yield return i; 
    } 
    public ArrayEnumerator<int> Bespoke() 
    { 
     return new ArrayEnumerator<int>(data); 
    } 
    public Foo() 
    { 
     data = new int[500, 500]; 
     for (int x = 0; x < 500; x++) 
      for (int y = 0; y < 500; y++) 
      { 
       data[x, y] = x + y; 
      } 
    } 
    static void Main() 
    { 
     Test(1); // for JIT 
     Test(500); // for real 
     Console.ReadKey(); // pause 
    } 
    static void Test(int count) 
    { 
     Foo foo = new Foo(); 
     int chk; 
     Stopwatch watch = Stopwatch.StartNew(); 
     chk = 0; 
     for (int i = 0; i < count; i++) 
     { 
      foreach (int j in foo.Basic()) 
      { 
       chk += j; 
      } 
     } 
     watch.Stop(); 
     Console.WriteLine("Basic: " + watch.ElapsedMilliseconds + "ms - " + chk); 

     watch = Stopwatch.StartNew(); 
     chk = 0; 
     for (int i = 0; i < count; i++) 
     { 
      foreach (int j in foo.Bespoke()) 
      { 
       chk += j; 
      } 
     } 
     watch.Stop(); 
     Console.WriteLine("Bespoke: " + watch.ElapsedMilliseconds + "ms - " + chk); 
    } 
}