在添加到MemoryStream之前，如何检查添加到MemoryStream的结果？

Question

I am creating an XML file using a Memory stream, in the following manner -

XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;

MemoryStream ms = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(ms, settings))
{
    // CREATE XML WITH STATEMENTS LIKE THIS
    writer.WriteStartElement("url", myUrl);
    writer.WriteEndElement();
}

Is there some way to check what the length of the resulting MemoryStream will be, before actually adding the element to the MemoryStream ?

Something like -

var sizeTotal = ms + (writer.WriteStartElement("url", myUrl);

The purpose of this is so I can check sizeTotal , make sure it's not too big before I write it to the MemoryStream .

I have a size limit of 10MB for the XML file I am generating. Could I write to a "temp" stream 1st, check the length, if the sizeTotal is less than 10MB, write to the element to the "real" stream. Else, if the sizeTotal is more than 10MB, I want to not add the element to the stream, generate the XML file, then start a new file.

Answer 1

There's no way I know of to determine how long an element will be before you actually write it. But you can determine how long the thing was, and then back up if you need to. The key is to get the current position of the MemoryStream before you begin the write, and subtract that from the position after writing. For example:

using (XmlWriter writer = XmlWriter.Create(ms, settings))
{
    long startPos = ms.Position;
    // write an element
    writer.WriteStartElement("url", myUrl);
    writer.WriteEndElement();
    writer.Flush();  // make sure data is flushed to the stream
    long endPos = ms.Position;

}

So if endPos goes beyond your size limit, you can copy the memory stream from 0 to startPos , and save it. You can then position the stream at 0 and retry your write. Something like:

using (XmlWriter writer = XmlWriter.Create(ms, settings))
{
    // write an element
    while (true)
    {
        long startPos = ms.Position;
        writer.WriteStartElement("url", myUrl);
        writer.WriteEndElement();
        writer.Flush();  // make sure data is flushed to the stream
        if (ms.Position < maxSize)
            break;
        // here, copy memory buffer from 0 to startPos and save to disk
        // then, reset position
        ms.Position = 0;
    }

    // write another element
    while (true)
    {
        // same thing, different element
    }

    // make sure to write the final buffer!
}

That's the general idea. Of course you'd want to make sure you don't go into an infinite loop if a single element exceeds the threshold value.

Note that I don't address the problem of XML fragments, which this technique will undoubtedly create. If you want your individual files to be valid XML, you'll have to keep track of which elements are opened, so when you write the partial file all those elements are closed. You'll also need to open those elements when you initialize the memory stream for the next bit. You can either do that in place of the ms.Position = 0; , or you can do that when you write the next fragment out.

Without knowing more about the larger problem (ie what you're doing with these partial files), I can't make specific recommendations about how to handle it.

Answer 2

You mean something like this?

var myUrl = "http://www.stackoverflow.com";
var encoding = Encoding.UTF8;

XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.Encoding = encoding;
var SOME_MAX_SIZE_IN_BYTES = 1024;
MemoryStream ms = new MemoryStream();
for(var i=0; i<10; i++)
{
    using (XmlWriter writer = XmlWriter.Create(ms, settings))
    {    
        // CREATE XML WITH STATEMENTS LIKE THIS
        writer.WriteStartElement("url", myUrl);
        writer.WriteEndElement();
        // in order to get a semi-accurate byte count, 
        // you need to force the flush to the underlying stream
        writer.Flush();
        var lengthInBytes = ms.Length;
        if(lengthInBytes > SOME_MAX_SIZE_IN_BYTES)
        {
            Console.WriteLine("TOO BIG!");
            break;
        }
    }
}

var xml = encoding.GetString(ms.ToArray());
Console.WriteLine(xml);