是否可以序列化包含yield语句的方法（或包含此类方法的类），以便在对类进行重新水化时，保留生成的迭代器的内部状态？
答案 0 :(得分：8)
是的，你可以这样做。有警告。
可以在此处找到使用yield序列化方法，反序列化和继续的示例：http://www.agilekiwi.com/dotnet/CountingDemo.cs（Web Archive Link）。
通常，尝试序列化而不做一些额外的工作将会失败。这是因为编译器生成的类没有标记Serializable属性。但是，你可以解决这个问题。
我会注意到它们没有标记为可序列化的原因是因为它们是一个实现细节，并且在将来版本中会发生重大变化，因此您可能无法在较新版本中反序列化它。
与我在how to serialize anonymous delegates上提出的问题相关，这也适用于此案例。
以下是“hack”的源代码：
// Copyright © 2007 John M Rusk (http://www.agilekiwi.com)
//
// You may use this source code in any manner you wish, subject to
// the following conditions:
//
// (a) The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// (b) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Soap;
namespace AgileKiwi.PersistentIterator.Demo
{
/// <summary>
/// This is the class we will enumerate over
/// </summary>
[Serializable]
public class SimpleEnumerable
{
public IEnumerator<string> Foo()
{
yield return "One";
yield return "Two";
yield return "Three";
}
#region Here is a more advanced example
// This shows that the solution even works for iterators which call other iterators
// See SimpleFoo below for a simpler example
public IEnumerator<string> AdvancedFoo()
{
yield return "One";
foreach (string s in Letters())
yield return "Two " + s;
yield return "Three";
}
private IEnumerable<string> Letters()
{
yield return "a";
yield return "b";
yield return "c";
}
#endregion
}
/// <summary>
/// This is the command-line program which calls the iterator and serializes the state
/// </summary>
public class Program
{
public static void Main()
{
// Create/restore the iterator
IEnumerator<string> e;
if (File.Exists(StateFile))
e = LoadIterator();
else
e = (new SimpleEnumerable()).Foo(); // start new iterator
// Move to next item and display it.
// We can't use foreach here, because we only want to get ONE
// result at a time.
if (e.MoveNext())
Console.WriteLine(e.Current);
else
Console.WriteLine("Finished. Delete the state.xml file to restart");
// Save the iterator state back to the file
SaveIterator(e);
// Pause if running from the IDE
if (Debugger.IsAttached)
{
Console.Write("Press any key...");
Console.ReadKey();
}
}
static string StateFile
{
get {
return Path.Combine(
Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
"State.xml");
}
}
static IEnumerator<string> LoadIterator()
{
using (FileStream stream = new FileStream(StateFile, FileMode.Open))
{
ISurrogateSelector selector = new EnumerationSurrogateSelector();
IFormatter f = new SoapFormatter(selector, new StreamingContext());
return (IEnumerator<string>)f.Deserialize(stream);
}
}
static void SaveIterator(IEnumerator<string> e)
{
using (FileStream stream = new FileStream(StateFile, FileMode.Create))
{
ISurrogateSelector selector = new EnumerationSurrogateSelector();
IFormatter f = new SoapFormatter(selector, new StreamingContext());
f.Serialize(stream, e);
}
#region Note: The above code puts the name of the compiler-generated enumerator class...
// into the serialized output. Under what circumstances, if any, might a recompile result in
// a different class name? I have not yet investigated what the answer might be.
// I suspect MS provide no guarantees in that regard.
#endregion
}
}
#region Helper classes to serialize iterator state
// See http://msdn.microsoft.com/msdnmag/issues/02/09/net/#S3
class EnumerationSurrogateSelector : ISurrogateSelector
{
ISurrogateSelector _next;
public void ChainSelector(ISurrogateSelector selector)
{
_next = selector;
}
public ISurrogateSelector GetNextSelector()
{
return _next;
}
public ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector)
{
if (typeof(System.Collections.IEnumerator).IsAssignableFrom(type))
{
selector = this;
return new EnumeratorSerializationSurrogate();
}
else
{
//todo: check this section
if (_next == null)
{
selector = null;
return null;
}
else
{
return _next.GetSurrogate(type, context, out selector);
}
}
}
}
// see http://msdn.microsoft.com/msdnmag/issues/02/09/net/#S3
class EnumeratorSerializationSurrogate : ISerializationSurrogate
{
public void GetObjectData(object obj, SerializationInfo info, StreamingContext context)
{
foreach(FieldInfo f in obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
info.AddValue(f.Name, f.GetValue(obj));
}
public object SetObjectData(object obj, SerializationInfo info, StreamingContext context,
ISurrogateSelector selector)
{
foreach (FieldInfo f in obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
f.SetValue(obj, info.GetValue(f.Name, f.FieldType));
return obj;
}
}
#endregion
}
答案 1 :(得分：5)
在内部，yield语句被转换为实现为实现IEnumerator接口的类的状态机。它允许同时使用多个foreach语句迭代结果集。该类对您的代码不可见，但未标记为可序列化。
所以，答案是否定的，这是不可能的。但是，您可以单独实现所需的枚举器，但它需要比yield更多的人工。
答案 2 :(得分：1)
只需确保在调用yield之前，将状态（即迭代器位置）保存在可序列化字段（位置字段或其他任何名称）中。然后，当反序列化类时，只需使用位置字段继续上次停止的地方。
但是，这什么时候会有用？您是否计划在foreach循环中序列化对象？如果你给你一个SetIteratorPosition()方法，默认为当前位置，也许你会更轻松。它比为现有明确定义的行为（产量）添加副作用更清晰，每个人都会理解IteratorPosition可以保存。
注意：方法无法序列化。您序列化数据，即属性和字段。
答案 3 :(得分：1)
是。无论你告诉它什么，任何返回IEnumerable的方法都可以拥有它自己的yield return代码。如果你序列化你的对象的内部状态，它的迭代次数和得到的程度，那么你可以在将来重新加载该状态，并在你离开的地方继续枚举。