#LINQPad optimize+

static string xml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<ListBucketResult>
    <Name>algresearch</Name>
    <Prefix/>
    <KeyCount>5</KeyCount>
    <MaxKeys>1000</MaxKeys>
    <IsTruncated>false</IsTruncated>
    @c

</ListBucketResult>

";

static string contents = @"<Contents>
        <Key>11d247ec-ca73-4ab9-a8ff-a5ffc446f8a4</Key>
        <LastModified>2021-02-25T10:29:26.000Z</LastModified>
        <ETag>&quot;5cc7bdc9132074539612aacde94d39ae&quot;</ETag>
        <Size>15</Size>
        <StorageClass>STANDARD</StorageClass>
    </Contents>";

void Main()
{
    Util.AutoScrollResults = true;
    BenchmarkRunner.Run<ParseBenchmark>();
}

public class IOEntry
{
    public IOEntry(string key)
    {
        Key = key;
    }

    public string Key { get; private set; }

    public DateTimeOffset? LastModificationTime { get; set; }

    public int Size { get; set; }

    public string ETag { get; set; }

    public string StorageClass { get; set; }
}

[ShortRunJob]
[MarkdownExporter]
//[SimpleJob]
//[RPlotExporter]
[MemoryDiagnoser]
//[DisassemblyDiagnoser]
public class ParseBenchmark
{
    public IReadOnlyCollection<IOEntry> ParseWithXmlReader(string xml, out string continuationToken)
    {
        continuationToken = null;
        var result = new List<IOEntry>();
        using (var sr = new StringReader(xml))
        {
            using (var xr = System.Xml.XmlReader.Create(sr))
            {
                while (xr.Read())
                {
                    if (xr.NodeType == XmlNodeType.Element)
                    {
                        switch (xr.Name)
                        {
                            case "NextContinuationToken":
                                break;
                            case "Contents":
                                string key = null;
                                string lastMod = null;
                                string eTag = null;
                                string size = null;
                                string storageClass = null;
                                // read all the elements in this
                                string en = null;
                                while (xr.Read() && !(xr.NodeType == XmlNodeType.EndElement && xr.Name == "Contents"))
                                {
                                    if (xr.NodeType == XmlNodeType.Element)
                                        en = xr.Name;
                                    else if (xr.NodeType == XmlNodeType.Text)
                                    {
                                        switch (en)
                                        {
                                            case "Key":
                                                key = xr.Value;
                                                break;
                                            case "LastModified":
                                                lastMod = xr.Value;
                                                break;
                                            case "ETag":
                                                eTag = xr.Value;
                                                break;
                                            case "Size":
                                                size = xr.Value;
                                                break;
                                            case "StorageClass":
                                                storageClass = xr.Value;
                                                break;
                                        }
                                    }
                                }

                                if (key != null)
                                {
                                    var entry = new IOEntry(key)
                                    {
                                        LastModificationTime = DateTimeOffset.Parse(lastMod),
                                        Size = int.Parse(size),
                                        ETag = eTag,
                                        StorageClass = storageClass
                                    };
                                    result.Add(entry);
                                }

                                break;
                        }
                    }
                }
            }
        }

        return result;
    }

    public IReadOnlyCollection<IOEntry> ParseWithXElement(string xml, out string continuationToken)
    {
        continuationToken = null;
        var result = new List<IOEntry>();

        XElement x = XElement.Parse(xml);
        continuationToken = x.Element("NextContinuationToken")?.Value;

        foreach(XElement c in x.Elements("Contents"))
        {
            var entry = new IOEntry(c.Element("Key").Value)
            {
                LastModificationTime = DateTimeOffset.Parse(c.Element("LastModified")?.Value),
                Size = int.Parse(c.Element("Size")?.Value),
                ETag = c.Element("ETag")?.Value,
                StorageClass = c.Element("StorageClass")?.Value
            };
            result.Add(entry);
        }

        return result;
    }

    private string _xml;

    [Params(10, 100, 1000, 10000, 100000)]
    public int EntryCount;

    [GlobalSetup]
    public void Setup()
    {
        var sb = new StringBuilder();
        for(int i = 0; i < EntryCount; i++)
        {
            sb.Append(contents);
        }

        _xml = xml.Replace("@c", sb.ToString());
    }

    [Benchmark]
    public IReadOnlyCollection<IOEntry> XmlReader()
    {
        return ParseWithXmlReader(_xml, out _);
    }

    [Benchmark]
    public IReadOnlyCollection<IOEntry> Linq()
    {
        return ParseWithXElement(_xml, out _);
    }

}