.NET: XmlReader vs Linq to XML Performance

#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 _);
	}

}