Por que não pode iterador métodos de apanhar 'ref' ou 'fora' parâmetros?
-
14-09-2019 - |
Pergunta
Eu tentei isso hoje cedo:
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
}
}
Qual é a lógica por trás disso?
Solução
C# iteradores são máquinas de estado internamente.Cada vez que você yield return
algo, o lugar onde você parou deverão ser guardados juntamente com o estado de variáveis locais, de modo que você pode obter de volta e continuar a partir daí.
Para manter este estado, o compilador C# cria uma classe para armazenar variáveis locais e o lugar em que ela deve continuar de.Não é possível ter uma ref
ou out
valor como um campo em uma classe.Consequentemente, se você estava autorizado a declarar um parâmetro como ref
ou out
, não haveria maneira de manter o instantâneo completo da função no momento em que nos tinha deixado.
EDITAR: Tecnicamente, nem todos os métodos que retornam IEnumerable<T>
são considerados os iteradores.Apenas aqueles que usam yield
para produzir uma sequência direta são considerados os iteradores.Portanto, enquanto a divisão do iterador em dois métodos é um bom e solução comuns, isso não contradiz o que eu disse.O exterior do método (que não usa yield
diretamente) é não considerado um iterador.
Outras dicas
Se você deseja devolver um iterador e um int do seu método, uma solução alternativa é a seguinte:
public class Bar : IFoo
{
public IEnumerable<int> GetItems( ref int somethingElse )
{
somethingElse = 42;
return GetItemsCore();
}
private IEnumerable<int> GetItemsCore();
{
yield return 7;
}
}
Você deve observar que nenhum código dentro de um método de iterador (ou seja, basicamente um método que contém yield return
ou yield break
) é executado até o MoveNext()
O método no enumerador é chamado. Então, se você foi capaz de usar out
ou ref
No seu método de iterador, você obteria um comportamento surpreendente como este:
// 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
Esta é uma armadilha comum, uma questão relacionada é a seguinte:
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
Portanto, um bom padrão é separar os métodos do iterador em duas partes: uma para executar imediatamente e outra que contém o código que deve ser executado preguiçosamente.
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
EDITAR:Se você realmente quer o comportamento em que mover o iterador modificaria o ref
-Parameter, você pode fazer algo assim:
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
Em um nível alto, uma variável ref pode apontar para muitos locais, incluindo os tipos de valor que estão na pilha. O tempo em que o iterador é criado inicialmente chamando o método do iterador e quando a variável REF seria atribuída são dois momentos muito diferentes. Não é possível garantir que a variável que originalmente foi passada por referência ainda existe quando o iterador realmente é executado. Portanto, não é permitido (ou verificável)
Outros explicaram por que seu iterador não pode ter um parâmetro REF. Aqui está uma alternativa simples:
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;
}
}
Se você tiver vários itens para entrar e sair, defina uma aula para mantê -los.
Eu tive esse problema usando funções, quando o valor que preciso retornar é derivado dos itens iterados:
// 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 );
}