Est-il possible de cloner un IEnumerable<T> exemple, l'enregistrement d'une copie de l'itération de l'état?

Le meilleur que vous pourriez faire est d'écrire quelque chose qui permet de garder une mémoire tampon (peut-être un Queue<T>) de données consommé de l'un et pas l'autre (ce qui serait gênant/cher si vous avez avancé un itérateur de 1M positions, mais à gauche de l'autre). Je vraiment pense que vous feriez mieux de repenser la conception, si, et seulement à l'aide de GetEnumerator() (c'est à dire un autre foreach) pour démarrer de nouveau - ou de la mémoire tampon de données (s'il est court) dans une liste/tableau/whatever.

Rien d'élégant construit en.

Mise à jour: peut-être une alternative intéressante design ici est "PushLINQ"; plutôt que de cloner l'itérateur, il permet à plusieurs "choses" à consommer les mêmes données-alimentation en même temps.

Dans cet exemple (levée de Jon de page) nous calculons plusieurs agrégats en parallèle:

//Create the data source to watch
DataProducer<Voter> voters = new DataProducer<Voter>();

//Add the aggregators
IFuture<int> total = voters.Count();
IFuture<int> adults = voters.Count(voter => voter.Age >= 18);
IFuture<int> children = voters.Where(voter => voter.Age < 18).Count();
IFuture<int> youngest = voters.Min(voter => voter.Age);
IFuture<int> oldest = voters.Select(voter => voter.Age).Max();

//Push all the data through
voters.ProduceAndEnd(Voter.AllVoters());

//Write out the results
Console.WriteLine("Total voters: {0}", total.Value);
Console.WriteLine("Adult voters: {0}", adults.Value);
Console.WriteLine("Child voters: {0}", children.Value);
Console.WriteLine("Youngest vote age: {0}", youngest.Value);
Console.WriteLine("Oldest voter age: {0}", oldest.Value);

OriginalL'auteur Marc Gravell

C'est complètement pas une réponse, mais l'expérience de pensée que j'ai trouvé intéressant...si vous avez un basé sur le rendement IEnumerable, je suppose que tu sais tout est généré par le compilateur de la magie. Si vous avez une telle bête, vous pourrait faire quelque chose comme ça... 😉

class Program
{
static void Main(string[] args)
{
var bar = new Program().Foo();
//Get a hook to the underlying compiler generated class
var barType = bar.GetType().UnderlyingSystemType;
var barCtor = barType.GetConstructor(new Type[] {typeof (Int32)});
var res = barCtor.Invoke(new object[] { -2}) as IEnumerable<int>;
//Get our enumerator
var resEnum = res.GetEnumerator();
resEnum.MoveNext();
resEnum.MoveNext();
Debug.Assert(resEnum.Current == 1);
//Extract and save our state
var nonPublicMap = new Dictionary<FieldInfo, object>();
var publicMap = new Dictionary<FieldInfo, object>();
var nonpublicfields = resEnum.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
var publicfields = resEnum.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
foreach(var field in nonpublicfields)
{
var value = field.GetValue(resEnum);
nonPublicMap[field] = value;
}
foreach (var field in publicfields)
{
var value = field.GetValue(resEnum);
publicMap[field] = value;                
}
//Move about
resEnum.MoveNext();
resEnum.MoveNext();
resEnum.MoveNext();
resEnum.MoveNext();
Debug.Assert(resEnum.Current == 5);
//Restore state            
foreach (var kvp in nonPublicMap)
{
kvp.Key.SetValue(resEnum, kvp.Value);
}
foreach (var kvp in publicMap)
{
kvp.Key.SetValue(resEnum, kvp.Value);                
}
//Move about
resEnum.MoveNext();
resEnum.MoveNext();
Debug.Assert(resEnum.Current == 3);
}
public IEnumerable<int> Foo()
{
for (int i = 0; i < 10; i++)
{
yield return i;
}
yield break;
}
}

OriginalL'auteur JerKimball

JerKimball avait une approche intéressante. J'essaie de le prendre au prochain niveau. On utilise à cette réflexion afin de créer une nouvelle instance, puis définit les valeurs sur la nouvelle instance. J'ai également trouvé ce chapitre à partir de C# en Profondeur pour être très utile.
Itérateur bloquer les détails de mise en œuvre: auto-généré de l'état des machines

static void Main()
{
var counter = new CountingClass();
var firstIterator = counter.CountingEnumerator();
Console.WriteLine("First list");
firstIterator.MoveNext();
Console.WriteLine(firstIterator.Current);
Console.WriteLine("First list cloned");
var secondIterator = EnumeratorCloner.Clone(firstIterator);
Console.WriteLine("Second list");
secondIterator.MoveNext();
Console.WriteLine(secondIterator.Current);
secondIterator.MoveNext();
Console.WriteLine(secondIterator.Current);
secondIterator.MoveNext();
Console.WriteLine(secondIterator.Current);
Console.WriteLine("First list");
firstIterator.MoveNext();
Console.WriteLine(firstIterator.Current);
firstIterator.MoveNext();
Console.WriteLine(firstIterator.Current);
}
public class CountingClass
{
public IEnumerator<int> CountingEnumerator()
{
int i = 1;
while (true)
{
yield return i;
i++;
}
}
}
public static class EnumeratorCloner
{
public static T Clone<T>(T source) where T : class, IEnumerator
{
var sourceType = source.GetType().UnderlyingSystemType;
var sourceTypeConstructor = sourceType.GetConstructor(new Type[] { typeof(Int32) });
var newInstance = sourceTypeConstructor.Invoke(new object[] { -2 }) as T;
var nonPublicFields = source.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
var publicFields = source.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
foreach (var field in nonPublicFields)
{
var value = field.GetValue(source);
field.SetValue(newInstance, value);
}
foreach (var field in publicFields)
{
var value = field.GetValue(source);
field.SetValue(newInstance, value);
}
return newInstance;
}
}

OriginalL'auteur BenMaddox