我喜欢 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 类型的结果中动态分页。从 block 中的数据库(例如 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 已经写出，同时仍在遍历可枚举。 (当然，我只是出于测试目的写入字符串，而您可能会写入文件。)

关于c# - 使用 C# XmlSerializer 为大型对象集写入 block 以避免内存不足，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28837438/