Save changes

Commit migrated from https://github.com/dotnet/corefx/commit/28b6ef63a6e81c9f23deb76c6b171e981d5897cc

diff --git a/src/libraries/Atom10FeedFormatter.cs b/src/libraries/Atom10FeedFormatter.cs
index b948a51..a6b6b48 100644 (file)
--- a/src/libraries/Atom10FeedFormatter.cs
+++ b/src/libraries/Atom10FeedFormatter.cs
@@ -497,7 +497,7 @@ namespace Microsoft.ServiceModel.Syndication
             return SyndicationFeedFormatter.CreateFeedInstance(_feedType);
         }
 
-        protected virtual async Task<SyndicationItem> ReadItemAsync(XmlReaderWrapper reader, SyndicationFeed feed)
+        protected virtual async Task<SyndicationItem> ReadItemAsync(XmlReader reader, SyndicationFeed feed)
         {
             if (feed == null)
             {
@@ -508,11 +508,14 @@ namespace Microsoft.ServiceModel.Syndication
                 throw new ArgumentNullException("reader");
             }
             SyndicationItem item = CreateItem(feed);
-            await ReadItemFromAsync(reader, item, feed.BaseUri);
+
+            XmlReaderWrapper readerWrapper = XmlReaderWrapper.CreateFromReader(reader);
+
+            await ReadItemFromAsync(readerWrapper, item, feed.BaseUri);
             return item;
         }
 
-        protected virtual async Task<IEnumerable<SyndicationItem>> ReadItemsAsync(XmlReaderWrapper reader, SyndicationFeed feed)
+        protected virtual async Task<IEnumerable<SyndicationItem>> ReadItemsAsync(XmlReader reader, SyndicationFeed feed)
         {
             if (feed == null)
             {
@@ -523,7 +526,10 @@ namespace Microsoft.ServiceModel.Syndication
                 throw new ArgumentNullException("reader");
             }
             NullNotAllowedCollection<SyndicationItem> items = new NullNotAllowedCollection<SyndicationItem>();
-            while (await reader.IsStartElementAsync(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace))
+
+            XmlReaderWrapper readerWrapper = XmlReaderWrapper.CreateFromReader(reader);
+
+            while (await readerWrapper.IsStartElementAsync(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace))
             {
                 items.Add(await ReadItemAsync(reader, feed));
             }

diff --git a/src/libraries/CategoriesDocument.cs b/src/libraries/CategoriesDocument.cs
index 485b4a3..52f5232 100644 (file)
--- a/src/libraries/CategoriesDocument.cs
+++ b/src/libraries/CategoriesDocument.cs
@@ -8,6 +8,7 @@ namespace Microsoft.ServiceModel.Syndication
     using System.Collections.Generic;
     using System.Collections.ObjectModel;
     using System.Runtime.CompilerServices;
+    using System.Threading.Tasks;
     using System.Xml;
 
     [TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
@@ -69,10 +70,10 @@ namespace Microsoft.ServiceModel.Syndication
             return new ReferencedCategoriesDocument(linkToCategoriesDocument);
         }
 
-        public static CategoriesDocument Load(XmlReaderWrapper reader)
+        public static async Task<CategoriesDocument> Load(XmlReader reader)
         {
             AtomPub10CategoriesDocumentFormatter formatter = new AtomPub10CategoriesDocumentFormatter();
-            formatter.ReadFrom(reader);
+            await formatter.ReadFrom(reader);
             return formatter.Document;
         }
 
@@ -91,7 +92,7 @@ namespace Microsoft.ServiceModel.Syndication
             return false;
         }
 
-        protected internal virtual bool TryParseElement(XmlReaderWrapper reader, string version)
+        protected internal virtual bool TryParseElement(XmlReader reader, string version)
         {
             return false;
         }

diff --git a/src/libraries/ExtensibleSyndicationObject.cs b/src/libraries/ExtensibleSyndicationObject.cs
index 077a0e4..088e02f 100644 (file)
--- a/src/libraries/ExtensibleSyndicationObject.cs
+++ b/src/libraries/ExtensibleSyndicationObject.cs
@@ -80,7 +80,7 @@ namespace Microsoft.ServiceModel.Syndication
             return buffer;
         }
 
-        internal void LoadElementExtensions(XmlReaderWrapper readerOverUnparsedExtensions, int maxExtensionSize)
+        internal void LoadElementExtensions(XmlReader readerOverUnparsedExtensions, int maxExtensionSize)
         {
             if (readerOverUnparsedExtensions == null)
             {

diff --git a/src/libraries/FeedUtils.cs b/src/libraries/FeedUtils.cs
index 83afcb5..a0d700c 100644 (file)
--- a/src/libraries/FeedUtils.cs
+++ b/src/libraries/FeedUtils.cs
@@ -12,7 +12,7 @@ namespace Microsoft.ServiceModel.Syndication
 
     internal static class FeedUtils
     {
-        public static string AddLineInfo(XmlReaderWrapper reader, string error)
+        public static string AddLineInfo(XmlReader reader, string error)
         {
             IXmlLineInfo lineInfo = reader as IXmlLineInfo;
             if (lineInfo != null && lineInfo.HasLineInfo())

diff --git a/src/libraries/ResourceCollectionInfo.cs b/src/libraries/ResourceCollectionInfo.cs
index 40722d9..5ead32d 100644 (file)
--- a/src/libraries/ResourceCollectionInfo.cs
+++ b/src/libraries/ResourceCollectionInfo.cs
@@ -143,7 +143,7 @@ namespace Microsoft.ServiceModel.Syndication
             return false;
         }
 
-        protected internal virtual bool TryParseElement(XmlReaderWrapper reader, string version)
+        protected internal virtual bool TryParseElement(XmlReader reader, string version)
         {
             return false;
         }

diff --git a/src/libraries/Rss20FeedFormatter.cs b/src/libraries/Rss20FeedFormatter.cs
index a9f714b..c67cb7a 100644 (file)
--- a/src/libraries/Rss20FeedFormatter.cs
+++ b/src/libraries/Rss20FeedFormatter.cs
@@ -34,41 +34,41 @@ namespace Microsoft.ServiceModel.Syndication
         private bool _preserveElementExtensions;
         private bool _serializeExtensionsAsAtom;
 
-        //Custom Parsers
-        public Func<string, XmlReaderWrapper, DateTimeOffset> DateParser { get; set; } // ParseDate
-        public Func<XmlReaderWrapper, TextSyndicationContent> TitleParser { get; set; }
-        public Func<XmlReaderWrapper, TextSyndicationContent> DescriptionParser { get; set; }
-        public Func<XmlReaderWrapper, string> LanguageParser { get; set; }
-        public Func<XmlReaderWrapper, TextSyndicationContent> CopyrightParser { get; set; }
-        public Func<XmlReaderWrapper, string> GeneratorParser { get; set; }
-        public Func<XmlReaderWrapper, Uri, SyndicationLink> OnReadLink { get; set; }
-        public Func<XmlReaderWrapper, SyndicationFeed, SyndicationPerson> ManagingEditorParser { get; set; }
-        public Func<XmlReaderWrapper, SyndicationFeed, bool> ImageParser { get; set; }
-        public Func<XmlReaderWrapper,SyndicationFeed,SyndicationItem> ItemParser { get; set; }
-        public Func<XmlReaderWrapper, SyndicationFeed, SyndicationCategory> FeedCategoryParser { get; set; }
+        ////Custom Parsers
+        public Func<string, XmlReader, DateTimeOffset> DateParser { get; set; } // ParseDate
+        //public Func<XmlReader, TextSyndicationContent> TitleParser { get; set; }
+        //public Func<XmlReader, TextSyndicationContent> DescriptionParser { get; set; }
+        //public Func<XmlReader, string> LanguageParser { get; set; }
+        //public Func<XmlReader, TextSyndicationContent> CopyrightParser { get; set; }
+        //public Func<XmlReader, string> GeneratorParser { get; set; }
+        //public Func<XmlReader, Uri, SyndicationLink> OnReadLink { get; set; }
+        //public Func<XmlReader, SyndicationFeed, SyndicationPerson> ManagingEditorParser { get; set; }
+        //public Func<XmlReader, SyndicationFeed, bool> ImageParser { get; set; }
+        //public Func<XmlReader,SyndicationFeed,SyndicationItem> ItemParser { get; set; }
+        //public Func<XmlReader, SyndicationFeed, SyndicationCategory> FeedCategoryParser { get; set; }
 
 
 
 
-        private bool OnReadImage(XmlReaderWrapper reader, SyndicationFeed result)
+        private async Task<bool> OnReadImage(XmlReaderWrapper reader, SyndicationFeed result)
         {
-            reader.ReadStartElement();
-            while (reader.IsStartElement())
+            await reader.ReadStartElementAsync();
+            while (await reader.IsStartElementAsync())
             {
-                if (reader.IsStartElement(Rss20Constants.UrlTag, Rss20Constants.Rss20Namespace))
+                if (await reader.IsStartElementAsync(Rss20Constants.UrlTag, Rss20Constants.Rss20Namespace))
                 {
-                    result.ImageUrl = new Uri(reader.ReadElementString(), UriKind.RelativeOrAbsolute);
+                    result.ImageUrl = new Uri(await reader.ReadElementStringAsync(), UriKind.RelativeOrAbsolute);
                 }
-                else if(reader.IsStartElement("link",Rss20Constants.Rss20Namespace))
+                else if(await reader.IsStartElementAsync("link",Rss20Constants.Rss20Namespace))
                 {
-                    result.ImageLink = new Uri(reader.ReadElementString(), UriKind.RelativeOrAbsolute);
+                    result.ImageLink = new Uri(await reader.ReadElementStringAsync(), UriKind.RelativeOrAbsolute);
                 }
-                else if (reader.IsStartElement("title", Rss20Constants.Rss20Namespace))
+                else if (await reader.IsStartElementAsync("title", Rss20Constants.Rss20Namespace))
                 {
-                    result.ImageTitle = new TextSyndicationContent(reader.ReadElementString());
+                    result.ImageTitle = new TextSyndicationContent(await reader.ReadElementStringAsync());
                 }
             }
-            reader.ReadEndElement(); // image
+            await reader.ReadEndElementAsync(); // image
             return true;
         }
 
@@ -76,28 +76,29 @@ namespace Microsoft.ServiceModel.Syndication
         //{
         //    //return ReadItem(reader,result);
         //}
-        private TextSyndicationContent OnReadTitle(XmlReaderWrapper reader)
+        private TextSyndicationContent OnReadTitle(XmlReader reader)
         {
             return new TextSyndicationContent(reader.ReadElementString());
         }
 
-        private TextSyndicationContent DescriptionParserAction(XmlReaderWrapper reader)
+        private TextSyndicationContent DescriptionParserAction(XmlReader reader)
         {
             return new TextSyndicationContent(reader.ReadElementString());
         }
 
-        private String LanguageParserAction(XmlReaderWrapper reader)
+        private String LanguageParserAction(XmlReader reader)
         {
             return reader.ReadElementString();
         }
 
-        private TextSyndicationContent CopyrightParserAction(XmlReaderWrapper reader)
+        private TextSyndicationContent CopyrightParserAction(XmlReader reader)
         {
             return new TextSyndicationContent(reader.ReadElementString());
         }
 
-        private string GeneratorParserAction(XmlReaderWrapper reader)
+        private string GeneratorParserAction(XmlReader reader)
         {
+            //XmlReaderWrapper readerWrapped = 
             return reader.ReadElementString();
         }
 
@@ -118,16 +119,16 @@ namespace Microsoft.ServiceModel.Syndication
         private void LoadDefaultParsers()
         {
             DateParser = DateParserAction;
-            TitleParser = OnReadTitle;
-            DescriptionParser = DescriptionParserAction;
-            LanguageParser = LanguageParserAction;
-            CopyrightParser = CopyrightParserAction;
-            GeneratorParser = GeneratorParserAction;
-            //ManagingEditorParser = ManagingEditorParserAction;
-            //OnReadLink = LinkParserAction;
-            //FeedCategoryParser = ReadCategory;
-            //ItemParser = OnReadItem;
-            ImageParser = OnReadImage;
+            //TitleParser = OnReadTitle;
+            //DescriptionParser = DescriptionParserAction;
+            //LanguageParser = LanguageParserAction;
+            //CopyrightParser = CopyrightParserAction;
+            //GeneratorParser = GeneratorParserAction;
+            ////ManagingEditorParser = ManagingEditorParserAction;
+            ////OnReadLink = LinkParserAction;
+            ////FeedCategoryParser = ReadCategory;
+            ////ItemParser = OnReadItem;
+            //ImageParser = OnReadImage;
         }
 
         public Rss20FeedFormatter()
@@ -479,7 +480,7 @@ namespace Microsoft.ServiceModel.Syndication
             return SyndicationFeedFormatter.CreateFeedInstance(_feedType);
         }
 
-        protected virtual async Task<SyndicationItem> ReadItemAsync(XmlReaderWrapper reader, SyndicationFeed feed)
+        protected virtual async Task<SyndicationItem> ReadItemAsync(XmlReader reader, SyndicationFeed feed)
         {
             if (feed == null)
             {
@@ -490,7 +491,8 @@ namespace Microsoft.ServiceModel.Syndication
                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
             }
             SyndicationItem item = CreateItem(feed);
-            await ReadItemFromAsync(reader, item, feed.BaseUri); // delegate => ItemParser(reader,item,feed.BaseUri);//
+            XmlReaderWrapper readerWrapper = XmlReaderWrapper.CreateFromReader(reader);
+            await ReadItemFromAsync(readerWrapper, item, feed.BaseUri); // delegate => ItemParser(reader,item,feed.BaseUri);//
             return item;
         }
 
@@ -1606,7 +1608,7 @@ namespace Microsoft.ServiceModel.Syndication
         }
 
         // Custom parsers
-        public DateTimeOffset DateParserAction(string dateTimeString, XmlReaderWrapper reader)
+        public DateTimeOffset DateParserAction(string dateTimeString, XmlReader reader)
         {
             bool parsed = false;
             //try

diff --git a/src/libraries/ServiceDocument.cs b/src/libraries/ServiceDocument.cs
index 219e02d..a81e06f 100644 (file)
--- a/src/libraries/ServiceDocument.cs
+++ b/src/libraries/ServiceDocument.cs
@@ -8,6 +8,7 @@ namespace Microsoft.ServiceModel.Syndication
     using System.Collections.Generic;
     using System.Collections.ObjectModel;
     using System.Runtime.CompilerServices;
+    using System.Threading.Tasks;
     using System.Xml;
 
     [TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
@@ -68,12 +69,12 @@ namespace Microsoft.ServiceModel.Syndication
             }
         }
 
-        public static ServiceDocument Load(XmlReaderWrapper reader)
+        public static ServiceDocument Load(XmlReader reader)
         {
             return Load<ServiceDocument>(reader);
         }
 
-        public static TServiceDocument Load<TServiceDocument>(XmlReaderWrapper reader)
+        public static TServiceDocument Load<TServiceDocument>(XmlReader reader)
             where TServiceDocument : ServiceDocument, new()
         {
             AtomPub10ServiceDocumentFormatter<TServiceDocument> formatter = new AtomPub10ServiceDocumentFormatter<TServiceDocument>();
@@ -101,7 +102,7 @@ namespace Microsoft.ServiceModel.Syndication
             return false;
         }
 
-        protected internal virtual bool TryParseElement(XmlReaderWrapper reader, string version)
+        protected internal virtual bool TryParseElement(XmlReader reader, string version)
         {
             return false;
         }

diff --git a/src/libraries/SyndicationCategory.cs b/src/libraries/SyndicationCategory.cs
index 9a9e077..bf06f2f 100644 (file)
--- a/src/libraries/SyndicationCategory.cs
+++ b/src/libraries/SyndicationCategory.cs
@@ -85,7 +85,7 @@ namespace Microsoft.ServiceModel.Syndication
             return false;
         }
 
-        protected internal virtual bool TryParseElement(XmlReaderWrapper reader, string version)
+        protected internal virtual bool TryParseElement(XmlReader reader, string version)
         {
             return false;
         }
@@ -100,7 +100,7 @@ namespace Microsoft.ServiceModel.Syndication
             _extensions.WriteElementExtensions(writer);
         }
 
-        internal void LoadElementExtensions(XmlReaderWrapper readerOverUnparsedExtensions, int maxExtensionSize)
+        internal void LoadElementExtensions(XmlReader readerOverUnparsedExtensions, int maxExtensionSize)
         {
             _extensions.LoadElementExtensions(readerOverUnparsedExtensions, maxExtensionSize);
         }

diff --git a/src/libraries/SyndicationContent.cs b/src/libraries/SyndicationContent.cs
index 9f22a82..5710d39 100644 (file)
--- a/src/libraries/SyndicationContent.cs
+++ b/src/libraries/SyndicationContent.cs
@@ -73,7 +73,7 @@ namespace Microsoft.ServiceModel.Syndication
             return new XmlSyndicationContent(Atom10Constants.XmlMediaType, dataContractObject, dataContractSerializer);
         }
 
-        public static XmlSyndicationContent CreateXmlContent(XmlReaderWrapper XmlReaderWrapper)
+        public static XmlSyndicationContent CreateXmlContent(XmlReader XmlReaderWrapper)
         {
             return new XmlSyndicationContent(XmlReaderWrapper);
         }

diff --git a/src/libraries/SyndicationElementExtension.cs b/src/libraries/SyndicationElementExtension.cs
index 5e00468..1fc8696 100644 (file)
--- a/src/libraries/SyndicationElementExtension.cs
+++ b/src/libraries/SyndicationElementExtension.cs
@@ -23,20 +23,20 @@ namespace Microsoft.ServiceModel.Syndication
         private string _outerName;
         private string _outerNamespace;
 
-        public SyndicationElementExtension(XmlReaderWrapper XmlReaderWrapper)
+        public SyndicationElementExtension(XmlReader reader)
         {
-            if (XmlReaderWrapper == null)
+            if (reader == null)
             {
                 throw new ArgumentNullException("XmlReaderWrapper");
             }
-            SyndicationFeedFormatter.MoveToStartElement(XmlReaderWrapper);
-            _outerName = XmlReaderWrapper.LocalName;
-            _outerNamespace = XmlReaderWrapper.NamespaceURI;
+            SyndicationFeedFormatter.MoveToStartElement(reader);
+            _outerName = reader.LocalName;
+            _outerNamespace = reader.NamespaceURI;
             _buffer = new XmlBuffer(int.MaxValue);
             using (XmlDictionaryWriter writer = _buffer.OpenSection(XmlDictionaryReaderQuotas.Max))
             {
                 writer.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
-                writer.WriteNode(XmlReaderWrapper, false);
+                writer.WriteNode(reader, false);
                 writer.WriteEndElement();
             }
             _buffer.CloseSection();

diff --git a/src/libraries/SyndicationElementExtensionCollection.cs b/src/libraries/SyndicationElementExtensionCollection.cs
index 65474be..c38602c 100644 (file)
--- a/src/libraries/SyndicationElementExtensionCollection.cs
+++ b/src/libraries/SyndicationElementExtensionCollection.cs
@@ -93,13 +93,13 @@ namespace Microsoft.ServiceModel.Syndication
             base.Add(new SyndicationElementExtension(xmlSerializerExtension, serializer));
         }
 
-        public void Add(XmlReaderWrapper XmlReaderWrapper)
+        public void Add(XmlReader reader)
         {
-            if (XmlReaderWrapper == null)
+            if (reader == null)
             {
                 throw new ArgumentNullException("XmlReaderWrapper");
             }
-            base.Add(new SyndicationElementExtension(XmlReaderWrapper));
+            base.Add(new SyndicationElementExtension(reader));
         }
 
         public XmlReader GetReaderAtElementExtensions()

diff --git a/src/libraries/SyndicationFeed.cs b/src/libraries/SyndicationFeed.cs
index c40758f..bc7ec67 100644 (file)
--- a/src/libraries/SyndicationFeed.cs
+++ b/src/libraries/SyndicationFeed.cs
@@ -394,7 +394,7 @@ namespace Microsoft.ServiceModel.Syndication
             return false;
         }
 
-        protected internal virtual bool TryParseElement(XmlReaderWrapper reader, string version)
+        protected internal virtual bool TryParseElement(XmlReader reader, string version)
         {
             return false;
         }
@@ -409,7 +409,7 @@ namespace Microsoft.ServiceModel.Syndication
             _extensions.WriteElementExtensions(writer);
         }
 
-        internal void LoadElementExtensions(XmlReaderWrapper readerOverUnparsedExtensions, int maxExtensionSize)
+        internal void LoadElementExtensions(XmlReader readerOverUnparsedExtensions, int maxExtensionSize)
         {
             _extensions.LoadElementExtensions(readerOverUnparsedExtensions, maxExtensionSize);
         }

diff --git a/src/libraries/SyndicationFeedFormatter.cs b/src/libraries/SyndicationFeedFormatter.cs
index f00c0b3..d7dc923 100644 (file)
--- a/src/libraries/SyndicationFeedFormatter.cs
+++ b/src/libraries/SyndicationFeedFormatter.cs
@@ -115,7 +115,7 @@ namespace Microsoft.ServiceModel.Syndication
             return GetNonNullValue<SyndicationPerson>(item.CreatePerson(), SR.ItemCreatedNullPerson);
         }
 
-        internal static protected void LoadElementExtensions(XmlReaderWrapper reader, SyndicationFeed feed, int maxExtensionSize)
+        internal static protected void LoadElementExtensions(XmlReader reader, SyndicationFeed feed, int maxExtensionSize)
         {
             if (feed == null)
             {
@@ -124,7 +124,7 @@ namespace Microsoft.ServiceModel.Syndication
             feed.LoadElementExtensions(reader, maxExtensionSize);
         }
 
-        internal static protected void LoadElementExtensions(XmlReaderWrapper reader, SyndicationItem item, int maxExtensionSize)
+        internal static protected void LoadElementExtensions(XmlReader reader, SyndicationItem item, int maxExtensionSize)
         {
             if (item == null)
             {
@@ -133,7 +133,7 @@ namespace Microsoft.ServiceModel.Syndication
             item.LoadElementExtensions(reader, maxExtensionSize);
         }
 
-        internal static protected void LoadElementExtensions(XmlReaderWrapper reader, SyndicationCategory category, int maxExtensionSize)
+        internal static protected void LoadElementExtensions(XmlReader reader, SyndicationCategory category, int maxExtensionSize)
         {
             if (category == null)
             {
@@ -142,7 +142,7 @@ namespace Microsoft.ServiceModel.Syndication
             category.LoadElementExtensions(reader, maxExtensionSize);
         }
 
-        internal static protected void LoadElementExtensions(XmlReaderWrapper reader, SyndicationLink link, int maxExtensionSize)
+        internal static protected void LoadElementExtensions(XmlReader reader, SyndicationLink link, int maxExtensionSize)
         {
             if (link == null)
             {
@@ -151,7 +151,7 @@ namespace Microsoft.ServiceModel.Syndication
             link.LoadElementExtensions(reader, maxExtensionSize);
         }
 
-        internal static protected void LoadElementExtensions(XmlReaderWrapper reader, SyndicationPerson person, int maxExtensionSize)
+        internal static protected void LoadElementExtensions(XmlReader reader, SyndicationPerson person, int maxExtensionSize)
         {
             if (person == null)
             {
@@ -227,12 +227,12 @@ namespace Microsoft.ServiceModel.Syndication
             return person.TryParseAttribute(name, ns, value, version);
         }
 
-        internal static protected bool TryParseContent(XmlReaderWrapper reader, SyndicationItem item, string contentType, string version, out SyndicationContent content)
+        internal static protected bool TryParseContent(XmlReader reader, SyndicationItem item, string contentType, string version, out SyndicationContent content)
         {
             return item.TryParseContent(reader, contentType, version, out content);
         }
 
-        internal static protected bool TryParseElement(XmlReaderWrapper reader, SyndicationFeed feed, string version)
+        internal static protected bool TryParseElement(XmlReader reader, SyndicationFeed feed, string version)
         {
             if (feed == null)
             {
@@ -242,7 +242,7 @@ namespace Microsoft.ServiceModel.Syndication
             return feed.TryParseElement(reader, version);
         }
 
-        internal static protected bool TryParseElement(XmlReaderWrapper reader, SyndicationItem item, string version)
+        internal static protected bool TryParseElement(XmlReader reader, SyndicationItem item, string version)
         {
             if (item == null)
             {
@@ -251,7 +251,7 @@ namespace Microsoft.ServiceModel.Syndication
             return item.TryParseElement(reader, version);
         }
 
-        internal static protected bool TryParseElement(XmlReaderWrapper reader, SyndicationCategory category, string version)
+        internal static protected bool TryParseElement(XmlReader reader, SyndicationCategory category, string version)
         {
             if (category == null)
             {
@@ -260,7 +260,7 @@ namespace Microsoft.ServiceModel.Syndication
             return category.TryParseElement(reader, version);
         }
 
-        internal static protected bool TryParseElement(XmlReaderWrapper reader, SyndicationLink link, string version)
+        internal static protected bool TryParseElement(XmlReader reader, SyndicationLink link, string version)
         {
             if (link == null)
             {
@@ -269,7 +269,7 @@ namespace Microsoft.ServiceModel.Syndication
             return link.TryParseElement(reader, version);
         }
 
-        internal static protected bool TryParseElement(XmlReaderWrapper reader, SyndicationPerson person, string version)
+        internal static protected bool TryParseElement(XmlReader reader, SyndicationPerson person, string version)
         {
             if (person == null)
             {

diff --git a/src/libraries/SyndicationItem.cs b/src/libraries/SyndicationItem.cs
index 98fd314..cd10a20 100644 (file)
--- a/src/libraries/SyndicationItem.cs
+++ b/src/libraries/SyndicationItem.cs
@@ -294,13 +294,13 @@ namespace Microsoft.ServiceModel.Syndication
             return false;
         }
 
-        protected internal virtual bool TryParseContent(XmlReaderWrapper reader, string contentType, string version, out SyndicationContent content)
+        protected internal virtual bool TryParseContent(XmlReader reader, string contentType, string version, out SyndicationContent content)
         {
             content = null;
             return false;
         }
 
-        protected internal virtual bool TryParseElement(XmlReaderWrapper reader, string version)
+        protected internal virtual bool TryParseElement(XmlReader reader, string version)
         {
             return false;
         }
@@ -315,7 +315,7 @@ namespace Microsoft.ServiceModel.Syndication
             _extensions.WriteElementExtensions(writer);
         }
 
-        internal void LoadElementExtensions(XmlReaderWrapper readerOverUnparsedExtensions, int maxExtensionSize)
+        internal void LoadElementExtensions(XmlReader readerOverUnparsedExtensions, int maxExtensionSize)
         {
             _extensions.LoadElementExtensions(readerOverUnparsedExtensions, maxExtensionSize);
         }

diff --git a/src/libraries/SyndicationItemFormatter.cs b/src/libraries/SyndicationItemFormatter.cs
index cd7ae9c..06fe5aa 100644 (file)
--- a/src/libraries/SyndicationItemFormatter.cs
+++ b/src/libraries/SyndicationItemFormatter.cs
@@ -111,22 +111,22 @@ namespace Microsoft.ServiceModel.Syndication
             return SyndicationFeedFormatter.CreatePerson(item);
         }
 
-        protected static void LoadElementExtensions(XmlReaderWrapper reader, SyndicationItem item, int maxExtensionSize)
+        protected static void LoadElementExtensions(XmlReader reader, SyndicationItem item, int maxExtensionSize)
         {
             SyndicationFeedFormatter.LoadElementExtensions(reader, item, maxExtensionSize);
         }
 
-        protected static void LoadElementExtensions(XmlReaderWrapper reader, SyndicationCategory category, int maxExtensionSize)
+        protected static void LoadElementExtensions(XmlReader reader, SyndicationCategory category, int maxExtensionSize)
         {
             SyndicationFeedFormatter.LoadElementExtensions(reader, category, maxExtensionSize);
         }
 
-        protected static void LoadElementExtensions(XmlReaderWrapper reader, SyndicationLink link, int maxExtensionSize)
+        protected static void LoadElementExtensions(XmlReader reader, SyndicationLink link, int maxExtensionSize)
         {
             SyndicationFeedFormatter.LoadElementExtensions(reader, link, maxExtensionSize);
         }
 
-        protected static void LoadElementExtensions(XmlReaderWrapper reader, SyndicationPerson person, int maxExtensionSize)
+        protected static void LoadElementExtensions(XmlReader reader, SyndicationPerson person, int maxExtensionSize)
         {
             SyndicationFeedFormatter.LoadElementExtensions(reader, person, maxExtensionSize);
         }
@@ -152,28 +152,28 @@ namespace Microsoft.ServiceModel.Syndication
         }
 
 
-        protected static bool TryParseContent(XmlReaderWrapper reader, SyndicationItem item, string contentType, string version, out SyndicationContent content)
+        protected static bool TryParseContent(XmlReader reader, SyndicationItem item, string contentType, string version, out SyndicationContent content)
         {
             return SyndicationFeedFormatter.TryParseContent(reader, item, contentType, version, out content);
         }
 
 
-        protected static bool TryParseElement(XmlReaderWrapper reader, SyndicationItem item, string version)
+        protected static bool TryParseElement(XmlReader reader, SyndicationItem item, string version)
         {
             return SyndicationFeedFormatter.TryParseElement(reader, item, version);
         }
 
-        protected static bool TryParseElement(XmlReaderWrapper reader, SyndicationCategory category, string version)
+        protected static bool TryParseElement(XmlReader  reader, SyndicationCategory category, string version)
         {
             return SyndicationFeedFormatter.TryParseElement(reader, category, version);
         }
 
-        protected static bool TryParseElement(XmlReaderWrapper reader, SyndicationLink link, string version)
+        protected static bool TryParseElement(XmlReader reader, SyndicationLink link, string version)
         {
             return SyndicationFeedFormatter.TryParseElement(reader, link, version);
         }
 
-        protected static bool TryParseElement(XmlReaderWrapper reader, SyndicationPerson person, string version)
+        protected static bool TryParseElement(XmlReader reader, SyndicationPerson person, string version)
         {
             return SyndicationFeedFormatter.TryParseElement(reader, person, version);
         }

diff --git a/src/libraries/SyndicationLink.cs b/src/libraries/SyndicationLink.cs
index bdd9512..fbceb3e 100644 (file)
--- a/src/libraries/SyndicationLink.cs
+++ b/src/libraries/SyndicationLink.cs
@@ -171,7 +171,7 @@ namespace Microsoft.ServiceModel.Syndication
             return false;
         }
 
-        protected internal virtual bool TryParseElement(XmlReaderWrapper reader, string version)
+        protected internal virtual bool TryParseElement(XmlReader reader, string version)
         {
             return false;
         }
@@ -186,7 +186,7 @@ namespace Microsoft.ServiceModel.Syndication
             _extensions.WriteElementExtensions(writer);
         }
 
-        internal void LoadElementExtensions(XmlReaderWrapper readerOverUnparsedExtensions, int maxExtensionSize)
+        internal void LoadElementExtensions(XmlReader readerOverUnparsedExtensions, int maxExtensionSize)
         {
             _extensions.LoadElementExtensions(readerOverUnparsedExtensions, maxExtensionSize);
         }

diff --git a/src/libraries/SyndicationPerson.cs b/src/libraries/SyndicationPerson.cs
index bb4bfb8..8502912 100644 (file)
--- a/src/libraries/SyndicationPerson.cs
+++ b/src/libraries/SyndicationPerson.cs
@@ -88,7 +88,7 @@ namespace Microsoft.ServiceModel.Syndication
             return false;
         }
 
-        protected internal virtual bool TryParseElement(XmlReaderWrapper reader, string version)
+        protected internal virtual bool TryParseElement(XmlReader reader, string version)
         {
             return false;
         }
@@ -103,7 +103,7 @@ namespace Microsoft.ServiceModel.Syndication
             _extensions.WriteElementExtensions(writer);
         }
 
-        internal void LoadElementExtensions(XmlReaderWrapper readerOverUnparsedExtensions, int maxExtensionSize)
+        internal void LoadElementExtensions(XmlReader readerOverUnparsedExtensions, int maxExtensionSize)
         {
             _extensions.LoadElementExtensions(readerOverUnparsedExtensions, maxExtensionSize);
         }

diff --git a/src/libraries/Workspace.cs b/src/libraries/Workspace.cs
index f9bdd51..5b70d1e 100644 (file)
--- a/src/libraries/Workspace.cs
+++ b/src/libraries/Workspace.cs
@@ -90,7 +90,7 @@ namespace Microsoft.ServiceModel.Syndication
             return false;
         }
 
-        protected internal virtual bool TryParseElement(XmlReaderWrapper reader, string version)
+        protected internal virtual bool TryParseElement(XmlReader reader, string version)
         {
             return false;
         }

diff --git a/src/libraries/XmlReaderWrapper.cs b/src/libraries/XmlReaderWrapper.cs
index 41a5835..9b03c3f 100644 (file)
--- a/src/libraries/XmlReaderWrapper.cs
+++ b/src/libraries/XmlReaderWrapper.cs
@@ -8,18 +8,18 @@ namespace Microsoft.ServiceModel.Syndication
     {
         private XmlReader reader;
 
-        private Func<Task<string>> getValueFunc;
-        private Func<Task<string>> readElementStringFunc;
-        private Func<Task<string>> readStringFunc;
-        private Func<Task> readEndElementFunc;
-        private Func<Task<XmlNodeType>> moveToContentFunc;
-        private Func<Task> readStartElementFunc;
-        private Func<string, string, Task> readStartElementFunc2;
-        private Func<Task<bool>> isStartElementFunc;
-        private Func<string, string, Task<bool>> isStartElementFunc2;
-        private Func<Task> skipFunc;
-        private Func<Task<bool>> readFunc;
-        private Func<Task<string>> readInnerXmlFunc;
+        private Func<XmlReaderWrapper, Task<string>> getValueFunc;
+        private Func<XmlReaderWrapper, Task<string>> readElementStringFunc;
+        private Func<XmlReaderWrapper, Task<string>> readStringFunc;
+        private Func<XmlReaderWrapper, Task> readEndElementFunc;
+        private Func<XmlReaderWrapper, Task<XmlNodeType>> moveToContentFunc;
+        private Func<XmlReaderWrapper, Task> readStartElementFunc;
+        private Func<XmlReaderWrapper, string, string, Task> readStartElementFunc2;
+        private Func<XmlReaderWrapper, Task<bool>> isStartElementFunc;
+        private Func<XmlReaderWrapper, string, string, Task<bool>> isStartElementFunc2;
+        private Func<XmlReaderWrapper, Task> skipFunc;
+        private Func<XmlReaderWrapper, Task<bool>> readFunc;
+        private Func<XmlReaderWrapper, Task<string>> readInnerXmlFunc;
 
         private XmlReaderWrapper(XmlReader reader)
         {
@@ -49,34 +49,36 @@ namespace Microsoft.ServiceModel.Syndication
 
         private void InitAsync()
         {
-            this.getValueFunc = new Func<Task<string>>(async () => { return await this.reader.GetValueAsync(); });
-            this.readElementStringFunc = new Func<Task<string>>(async () => { return await ReadElementStringAsync(this.reader); });
-            this.readStringFunc = new Func<Task<string>>(async () => { return await ReadStringAsync(this.reader); });
-            this.readEndElementFunc = new Func<Task>(async () => { await ReadEndElementAsync(this.reader); });
-            this.moveToContentFunc = new Func<Task<XmlNodeType>>(async () => { return await this.reader.MoveToContentAsync(); });
-            this.readStartElementFunc = new Func<Task>(async () => { await ReadStartElementAsync(this.reader); });
-            this.readStartElementFunc2 = new Func<string, string, Task>(async (localname, ns) => { await ReadStartElementAsync(this.reader, localname, ns); });
-            this.isStartElementFunc = new Func<Task<bool>>(async () => { return await IsStartElementAsync(this.reader); });
-            this.isStartElementFunc2 = new Func<string, string, Task<bool>>(async (localname, ns) => { return await IsStartElementAsync(this.reader, localname, ns); });
-            this.skipFunc = new Func<Task>(async () => { await this.reader.SkipAsync(); });
-            this.readFunc = new Func<Task<bool>>(async () => { return await this.reader.ReadAsync(); });
-            this.readInnerXmlFunc = new Func<Task<string>>(async () => { return await this.ReadInnerXmlAsync(); });
+            this.getValueFunc = new Func<XmlReaderWrapper, Task<string>>((thisPtr) => { return thisPtr.reader.GetValueAsync(); });
+
+            this.readElementStringFunc = new Func<XmlReaderWrapper, Task<string>>((thisPtr) => { return ReadElementStringAsync(thisPtr.reader); });
+            this.readStringFunc = new Func<XmlReaderWrapper, Task<string>>((thisPtr) => { return ReadStringAsync(thisPtr.reader); });
+            this.readEndElementFunc = new Func<XmlReaderWrapper, Task>( (thisPtr) => {  return ReadEndElementAsync(thisPtr.reader); });
+            this.moveToContentFunc = new Func<XmlReaderWrapper, Task<XmlNodeType>>((thisPtr) => { return thisPtr.reader.MoveToContentAsync(); });
+            this.readStartElementFunc = new Func<XmlReaderWrapper, Task>((thisPtr) => { return ReadStartElementAsync(thisPtr.reader); });
+            this.readStartElementFunc2 = new Func<XmlReaderWrapper, string, string, Task>((thisPtr, localname, ns) => { return ReadStartElementAsync(thisPtr.reader, localname, ns); });
+            this.isStartElementFunc = new Func<XmlReaderWrapper, Task<bool>>((thisPtr) => { return IsStartElementAsync(thisPtr.reader); });
+            this.isStartElementFunc2 = new Func<XmlReaderWrapper, string, string, Task<bool>>((thisPtr, localname, ns) => { return IsStartElementAsync(thisPtr.reader, localname, ns); });
+            this.skipFunc = new Func<XmlReaderWrapper, Task>((thisPtr) => { return thisPtr.reader.SkipAsync(); });
+            this.readFunc = new Func<XmlReaderWrapper, Task<bool>>((thisPtr) => { return thisPtr.reader.ReadAsync(); });
+            this.readInnerXmlFunc = new Func<XmlReaderWrapper, Task<string>>((thisPtr) => { return thisPtr.ReadInnerXmlAsync(); });
         }
 
         private void Init()
         {
-            this.getValueFunc = new Func<Task<string>>(() => { return Task.FromResult<string>(this.reader.Value); });
-            this.readElementStringFunc = new Func<Task<string>>(() => { return Task.FromResult<string>(this.reader.ReadElementString()); });
-            this.readStringFunc = new Func<Task<string>>(() => { return Task.FromResult<string>(this.reader.ReadString()); });
-            this.readEndElementFunc = new Func<Task>(() => { this.reader.ReadEndElement(); return Task.CompletedTask; });
-            this.moveToContentFunc = new Func<Task<XmlNodeType>>(() => { return Task.FromResult<XmlNodeType>(this.reader.MoveToContent()); });
-            this.readStartElementFunc = new Func<Task>(() => { this.reader.ReadStartElement(); return Task.CompletedTask; });
-            this.readStartElementFunc2 = new Func<string, string, Task>((localname, ns) => { this.reader.ReadStartElement(localname, ns); return Task.CompletedTask; });
-            this.isStartElementFunc = new Func<Task<bool>>(() => { return Task.FromResult<bool>(this.reader.IsStartElement()); });
-            this.isStartElementFunc2 = new Func<string, string, Task<bool>>((localname, ns) => { return Task.FromResult<bool>(this.reader.IsStartElement(localname, ns)); });
-            this.skipFunc = new Func<Task>(() => { this.reader.Skip(); return Task.CompletedTask; });
-            this.readFunc = new Func<Task<bool>>(() => { return Task.FromResult<bool>(this.reader.Read()); });
-            this.readInnerXmlFunc = new Func<Task<string>>(() => { return Task.FromResult<string>(this.reader.ReadInnerXml()); });
+            this.getValueFunc = new Func<XmlReaderWrapper, Task<string>>((thisPtr) => { return Task.FromResult<string>(thisPtr.reader.Value); });
+
+            this.readElementStringFunc = new Func<XmlReaderWrapper, Task<string>>((thisPtr) => { return Task.FromResult<string>(this.reader.ReadElementString()); });
+            this.readStringFunc = new Func<XmlReaderWrapper, Task<string>>((thisPtr) => { return Task.FromResult<string>(this.reader.ReadString()); });
+            this.readEndElementFunc = new Func<XmlReaderWrapper, Task>((thisPtr) => { this.reader.ReadEndElement(); return Task.CompletedTask; });
+            this.moveToContentFunc = new Func<XmlReaderWrapper, Task<XmlNodeType>>((thisPtr) => { return Task.FromResult<XmlNodeType>(this.reader.MoveToContent()); });
+            this.readStartElementFunc = new Func<XmlReaderWrapper, Task>((thisPtr) => { this.reader.ReadStartElement(); return Task.CompletedTask; });
+            this.readStartElementFunc2 = new Func<XmlReaderWrapper, string, string, Task>((thisPtr, localname, ns) => { this.reader.ReadStartElement(localname, ns); return Task.CompletedTask; });
+            this.isStartElementFunc = new Func<XmlReaderWrapper, Task<bool>>((thisPtr) => { return Task.FromResult<bool>(this.reader.IsStartElement()); });
+            this.isStartElementFunc2 = new Func<XmlReaderWrapper, string, string, Task<bool>>((thisPtr, localname, ns) => { return Task.FromResult<bool>(this.reader.IsStartElement(localname, ns)); });
+            this.skipFunc = new Func<XmlReaderWrapper, Task>((thisPtr) => { this.reader.Skip(); return Task.CompletedTask; });
+            this.readFunc = new Func<XmlReaderWrapper, Task<bool>>((thisPtr) => { return Task.FromResult<bool>(this.reader.Read()); });
+            this.readInnerXmlFunc = new Func<XmlReaderWrapper, Task<string>>((thisPtr) => { return Task.FromResult<string>(this.reader.ReadInnerXml()); });
         }
 
         public override XmlNodeType NodeType
@@ -237,61 +239,61 @@ namespace Microsoft.ServiceModel.Syndication
 
         public override Task<string> GetValueAsync()
         {
-            return this.getValueFunc();
+            return this.getValueFunc(this);
         }
 
         public Task<string> ReadElementStringAsync()
         {
-            return this.readElementStringFunc();
+            return this.readElementStringFunc(this);
         }
 
         public Task<string> ReadStringAsync()
         {
-            return this.readStringFunc();
+            return this.readStringFunc(this);
         }
 
         public Task ReadEndElementAsync()
         {
-            return this.readEndElementFunc();
+            return this.readEndElementFunc(this);
         }
 
         public override Task<XmlNodeType> MoveToContentAsync()
         {
-            return this.moveToContentFunc();
+            return this.moveToContentFunc(this);
         }
 
         public Task ReadStartElementAsync()
         {
-            return this.readStartElementFunc();
+            return this.readStartElementFunc(this);
         }
 
         public Task ReadStartElementAsync(string localname, string ns)
         {
-            return this.readStartElementFunc2(localname, ns);
+            return this.readStartElementFunc2(this, localname, ns);
         }
 
         public Task<bool> IsStartElementAsync()
         {
-            return this.isStartElementFunc();
+            return this.isStartElementFunc(this);
         }
 
         public Task<bool> IsStartElementAsync(string localname, string ns)
         {
-            return this.isStartElementFunc2(localname, ns);
+            return this.isStartElementFunc2(this, localname, ns);
         }
 
         public override Task SkipAsync()
         {
-            return this.skipFunc();
+            return this.skipFunc(this);
         }
 
         public override Task<bool> ReadAsync()
         {
-            return this.readFunc();
+            return this.readFunc(this);
         }
         public override Task<string> ReadInnerXmlAsync()
         {
-            return readInnerXmlFunc();
+            return readInnerXmlFunc(this);
         }
         private static async Task ReadStartElementAsync(XmlReader reader)
         {

diff --git a/src/libraries/XmlSyndicationContent.cs b/src/libraries/XmlSyndicationContent.cs
index 4e95086..389c14f 100644 (file)
--- a/src/libraries/XmlSyndicationContent.cs
+++ b/src/libraries/XmlSyndicationContent.cs
@@ -19,7 +19,7 @@ namespace Microsoft.ServiceModel.Syndication
         // Saves the element in the reader to the buffer (attributes preserved)
         // Type is populated from type attribute on reader
         // Reader must be positioned at an element
-        public XmlSyndicationContent(XmlReaderWrapper reader)
+        public XmlSyndicationContent(XmlReader reader)
         {
             if (reader == null)
             {

diff --git a/src/libraries/tests/BasicScenarioTests.cs b/src/libraries/tests/BasicScenarioTests.cs
index fc3e427..765aa18 100644 (file)
--- a/src/libraries/tests/BasicScenarioTests.cs
+++ b/src/libraries/tests/BasicScenarioTests.cs
@@ -291,11 +291,26 @@ namespace Microsoft.ServiceModel.Syndication.Tests
             Task<SyndicationFeed> atom = SyndicationFeed.LoadAsync(reader);
             Task<SyndicationFeed> rss = SyndicationFeed.LoadAsync(reader2);
 
+           
+
+            //atom.re
+
             await Task.WhenAll(atom, rss);
 
             Assert.True(atom.Result.Items != null);
             Assert.True(rss.Result.Items != null);
         }
+
+        [Fact]
+        public static async Task SyndicationFeed_BigFeedTest()
+        {
+            
+            XmlReaderSettings settings = new XmlReaderSettings();
+            settings.Async = true;
+            XmlReader reader = XmlReader.Create(@"TestFeeds\feed300_mb.xml",settings);
+            SyndicationFeed sf = await SyndicationFeed.LoadAsync(reader);
+        }
+
     }
 }