45

私は今日これを試しました：

public interface IFoo
{
    IEnumerable<int> GetItems_A( ref int somethingElse );
    IEnumerable<int> GetItems_B( ref int somethingElse );
}


public class Bar : IFoo
{
    public IEnumerable<int> GetItems_A( ref int somethingElse )
    {
        // Ok...
    }

    public IEnumerable<int> GetItems_B( ref int somethingElse )
    {
        yield return 7; // CS1623: Iterators cannot have ref or out parameters            

    }
}

この背後にある理論的根拠は何ですか?

4

5 に答える 5

57

C# イテレータは、内部的にステート マシンです。何かをするたびyield returnに、中断した場所をローカル変数の状態とともに保存して、そこから戻って続行できるようにする必要があります。

この状態を保持するために、C# コンパイラは、ローカル変数とそれが続く場所を保持するクラスを作成します。refまたはout値をクラスのフィールドとして持つことはできません。したがって、パラメーターをreforとして宣言することが許可されている場合out、中断した時点での関数の完全なスナップショットを保持する方法はありません。

編集:技術的には、返さIEnumerable<T>れるすべてのメソッドがイテレータと見なされるわけではありません。yieldシーケンスを直接生成するために使用するものだけが反復子と見なされます。したがって、反復子を 2 つのメソッドに分割することは適切で一般的な回避策ですが、今述べたことと矛盾することはありません。外側のメソッド (yield直接使用しない) は反復子とは見なされません。

于 2009-06-15T23:50:29.820 に答える
25

メソッドから反復子と int の両方を返したい場合の回避策は次のとおりです。

public class Bar : IFoo
{
    public IEnumerable<int> GetItems( ref int somethingElse )
    {
        somethingElse = 42;
        return GetItemsCore();
    }

    private IEnumerable<int> GetItemsCore();
    {
        yield return 7;
    }
}

Enumeratorのメソッドが呼び出されるまで、反復子メソッド (つまり、基本的にyield returnorを含むメソッド) 内のコードは実行されないことに注意してください。したがって、反復子メソッドでorを使用できた場合、次のような驚くべき動作が得られます。yield breakMoveNext()outref

// This will not compile:
public IEnumerable<int> GetItems( ref int somethingElse )
{
    somethingElse = 42;
    yield return 7;
}

// ...
int somethingElse = 0;
IEnumerable<int> items = GetItems( ref somethingElse );
// at this point somethingElse would still be 0
items.GetEnumerator().MoveNext();
// but now the assignment would be executed and somethingElse would be 42

これはよくある落とし穴です。関連する問題は次のとおりです。

public IEnumerable<int> GetItems( object mayNotBeNull ){
  if( mayNotBeNull == null )
    throw new NullPointerException();
  yield return 7;
}

// ...
IEnumerable<int> items = GetItems( null ); // <- This does not throw
items.GetEnumerators().MoveNext();                    // <- But this does

したがって、反復子メソッドを 2 つの部分に分けるのが適切なパターンです。1 つはすぐに実行する部分、もう 1 つは遅延実行するコードを含む部分です。

public IEnumerable<int> GetItems( object mayNotBeNull ){
  if( mayNotBeNull == null )
    throw new NullPointerException();
  // other quick checks
  return GetItemsCore( mayNotBeNull );
}

private IEnumerable<int> GetItemsCore( object mayNotBeNull ){
  SlowRunningMethod();
  CallToDatabase();
  // etc
  yield return 7;
}    
// ...
IEnumerable<int> items = GetItems( null ); // <- Now this will throw

編集: イテレータを移動すると - パラメータが変更される動作が本当に必要な場合は、次のrefようにすることができます。

public static IEnumerable<int> GetItems( Action<int> setter, Func<int> getter )
{
    setter(42);
    yield return 7;
}

//...

int local = 0;
IEnumerable<int> items = GetItems((x)=>{local = x;}, ()=>local);
Console.WriteLine(local); // 0
items.GetEnumerator().MoveNext();
Console.WriteLine(local); // 42
于 2009-06-16T08:02:04.900 に答える
5

他の人は、イテレータが ref パラメータを持つことができない理由を説明しています。簡単な代替手段を次に示します。

public interface IFoo
{
    IEnumerable<int> GetItems( int[] box );
    ...
}

public class Bar : IFoo
{
    public IEnumerable<int> GetItems( int[] box )
    {
        int value = box[0];
        // use and change value and yield to your heart's content
        box[0] = value;
    }
}

出し入れするアイテムが複数ある場合は、それらを保持するクラスを定義します。

于 2014-06-12T03:57:43.150 に答える
5

高いレベルでは、ref 変数は、スタック上の値の型を含む多くの場所を指すことができます。iterator メソッドを呼び出して iterator が最初に作成される時間と、ref 変数が割り当てられる時間は、2 つの非常に異なる時間です。イテレータが実際に実行されたときに、最初に参照によって渡された変数がまだ残っていることを保証することはできません。したがって、許可されていません（または検証可能ではありません）

于 2009-06-16T00:03:45.607 に答える
1

I've gotten around this problem using functions, when the value that I need to return is derived from the iterated items:

// One of the problems with Enumerable.Count() is
// that it is a 'terminator', meaning that it will
// execute the expression it is given, and discard
// the resulting sequence. To count the number of
// items in a sequence without discarding it, we 
// can use this variant that takes an Action<int>
// (or Action<long>), invokes it and passes it the
// number of items that were yielded.
//
// Example: This example allows us to find out
//          how many items were in the original
//          source sequence 'items', as well as
//          the number of items consumed by the
//          call to Sum(), without causing any 
//          LINQ expressions involved to execute
//          multiple times.
// 
//   int start = 0;    // the number of items from the original source
//   int finished = 0; // the number of items in the resulting sequence
//
//   IEnumerable<KeyValuePair<string, double>> items = // assumed to be an iterator
//
//   var result = items.Count( i => start = i )
//                   .Where( p => p.Key = "Banana" )
//                      .Select( p => p.Value )
//                         .Count( i => finished = i )
//                            .Sum();
//
//   // by getting the count of items operated 
//   // on by Sum(), we can calculate an average:
// 
//   double average = result / (double) finished; 
//
//   Console.WriteLine( "started with {0} items", start );
//   Console.WriteLine( "finished with {0} items", finished );
//

public static IEnumerable<T> Count<T>( 
    this IEnumerable<T> source, 
    Action<int> receiver )
{
  int i = 0;
  foreach( T item in source )
  {
    yield return item;
    ++i ;
  }
  receiver( i );
}

public static IEnumerable<T> Count<T>( 
    this IEnumerable<T> source, 
    Action<long> receiver )
{
  long i = 0;
  foreach( T item in source )
  {
    yield return item;
    ++i ;
  }
  receiver( i );
}
于 2012-03-06T09:58:40.223 に答える