我喜欢XmlSerialize的工作方式,如此简单,优雅且具有= p属性.但是,在序列化为xml文件之前建立所有对象的集合时,我遇到了内存不足的问题.

我正在从SQL数据库中填充对象,并打算使用XmlSerialize将对象写出为XML.它适用于小的子集,但是如果我尝试从数据库中获取所有对象,则会遇到“内存不足”异常.

XmlSerialize是否具有某种功能,可以让我从数据库中抓取100个对象的批处理,然后编写它们,抓取下一批100个对象并附加到xml？

我希望我不必陷入XmlDocument或需要更多手动编码工作的事情…

解决方法:

实际上,XmlSerializer可以在序列化时将可枚举的数据流入和流出.对于实现IEnumerable< T>的类,它具有特殊的处理方式.从docs开始：

The XmlSerializer gives special treatment to classes that implement IEnumerable or ICollection. A class that implements IEnumerable must implement a public Add method that takes a single parameter. The Add method’s parameter must be of the same type as is returned from the Current property on the value returned from GetEnumerator, or one of that type’s bases.

序列化此类时,XmlSerializer只是简单地遍历可枚举的过程,将每个当前值写入输出流.它不会首先将整个可枚举加载到列表中.因此,如果您有一些Linq查询以块的形式动态地分页从数据库中检索类型T的结果(例如here),则可以使用以下包装器将它们全部序列化而不用一次加载它们：

// Proxy class for any enumerable with the requisite `Add` methods.
public class EnumerableProxy<T> : IEnumerable<T>
{
    [XmlIgnore]
    public IEnumerable<T> BaseEnumerable { get; set; }

    public void Add(T obj)
    {
        throw new NotImplementedException();
    }

    #region IEnumerable<T> Members

    public IEnumerator<T> GetEnumerator()
    {
        if (BaseEnumerable == null)
            return Enumerable.Empty<T>().GetEnumerator();
        return BaseEnumerable.GetEnumerator();
    }

    #endregion

    #region IEnumerable Members

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion
}

请注意,此类仅对序列化有用,而对反序列化无效.这是一个如何使用它的示例：

public class RootObject<T>
{
    [XmlIgnore]
    public IEnumerable<T> Results { get; set; }

    [XmlArray("Results")]
    public EnumerableProxy<T> ResultsProxy { 
        get
        {
            return new EnumerableProxy<T> { BaseEnumerable = Results };
        }
        set
        {
            throw new NotImplementedException();
        }
    }
}

public class TestClass
{
    XmlWriter xmlWriter;
    TextWriter textWriter;

    public void Test()
    {
        try
        {
            var root = new RootObject<int>();
            root.Results = GetResults();

            using (textWriter = new StringWriter())
            {
                var settings = new XmlWriterSettings { Indent = true, IndentChars = "  " };
                using (xmlWriter = XmlWriter.Create(textWriter, settings))
                {
                    (new XmlSerializer(root.GetType())).Serialize(xmlWriter, root);
                }
                var xml = textWriter.ToString();
                Debug.WriteLine(xml);
            }
        }
        finally
        {
            xmlWriter = null;
            textWriter = null;
        }
    }

    IEnumerable<int> GetResults()
    {
        foreach (var i in Enumerable.Range(0, 1000))
        {
            if (i > 0 && (i % 500) == 0)
            {
                HalfwayPoint();
            }
            yield return i;
        }
    }

    private void HalfwayPoint()
    {
        if (xmlWriter != null)
        {
            xmlWriter.Flush();
            var xml = textWriter.ToString();
            Debug.WriteLine(xml);
        }
    }
}

如果您在HalfwayPoint()中设置一个中断,您将看到一半的XML已经被写出,同时仍然遍历该枚举. (当然,出于测试目的,我只是写一个字符串,而您可能正在写一个文件.)