C# Atom10FeedFormatter.ReadFrom方法代码示例

        public List<BannerItem> FbItems()
        {
            Atom10FeedFormatter formatter = new Atom10FeedFormatter();

            using (XmlReader reader = XmlReader.Create(ConfigurationManager.AppSettings["FacebookFeed"]))
            {
                formatter.ReadFrom(reader);
            }

            var bannerItems = new List<BannerItem>();

            foreach (var e in formatter.Feed.Items)
            {
                if (!e.Title.Text.StartsWith("Wallflux"))
                {
                    BannerItem le = new BannerItem();
                    le.title = e.Title.Text;
                    le.content = new entryContent
                    {
                        Value = ((TextSyndicationContent)e.Content).Text
                    };

                    le.link = new entryLink
                    {
                        href = e.Id,
                        target = "_blank"
                    };
                    le.updated = e.LastUpdatedTime.DateTime.ToShortDateString();
                    le.published = "Published on facebook "+e.PublishDate.DateTime.ToShortDateString();
                    le.TypeOfContent = Enum.GetName(typeof(TypeOfContent), TypeOfContent.FacebookPost);
                    bannerItems.Add(le);
                }
            }
            return bannerItems;

            /* sparas, extrahera bilder
            List<RssFeedItem> rssItems = new List<RssFeedItem>();
                    Stream stream = e.Result;
                    XmlReader response = XmlReader.Create(stream);
                    SyndicationFeed feeds = SyndicationFeed.Load(response);
                    foreach (SyndicationItem f in feeds.Items)
                    {
                        RssFeedItem rssItem = new RssFeedItem();

                        rssItem.Description = f.Summary.Text;

             const string rx =  @"(?<=img\s+src\=[\x27\x22])(?<Url>[^\x27\x22]*)(?=[\x27\x22])";
                        foreach (Match m in Regex.Matches(f.Summary.Text, rx, RegexOptions.IgnoreCase | RegexOptions.Multiline))
                        {
                            string src = m.Groups[1].Value;
                            if (src.StartsWith("//")) // Google RSS has it
                            {
                                src = src.Replace("//", "http://");
                            }

                            rssItem.ImageLinks.Add(src);
                        }

            */
        }

 public FeedData Build(string data, string url)
 {
     var formatter = new Atom10FeedFormatter();
     using (var reader = new StringReader(data))
     {
         using (var xmlReader = XmlReader.Create(reader))
         {
             formatter.ReadFrom(xmlReader);
             var feed = formatter.Feed;
             return new FeedData
             {
                 Id = Guid.Parse(feed.Id),
                 DateCreated = feed.LastUpdatedTime.UtcDateTime,
                 PreviousUri = GetUriFromLink(PrevInArchiveRelationshipType, feed),
                 NextUri = GetUriFromLink(NextInArchiveRelationshipType, feed),
                 Messages = feed.Items.Select(x =>
                 {
                     return new Message
                     {
                         Body = GetXmlString(x),
                         CreatedAt = x.LastUpdatedTime.UtcDateTime,
                         Id = Guid.Parse(x.Id),
                         FeedUri = url
                     };
                 }).ToArray()
             };
         }
     }
 }

        public static IList<Feed> GetFeeds()
        {
            var urls = new[]
                {
                    "http://www.simplyvinay.com/GetBlogRss.aspx", "http://www.bbc.co.uk/blogs/formula1/rss.xml",
                    "http://feeds.feedburner.com/AyendeRahien"
                };
            var list = new List<Feed>();

            foreach (var url in urls)
            {
                using (var reader = new CustomXmlReader(url))
                {
                    if (reader.ReadState == ReadState.Initial)
                        reader.MoveToContent();

                    var atom = new Atom10FeedFormatter();
                    if (atom.CanRead(reader))
                    {
                        atom.ReadFrom(reader);
                        list.AddRange(GenerateFeed(atom.Feed, true));
                    }

                    var rss = new Rss20FeedFormatter();
                    if (rss.CanRead(reader))
                    {
                        rss.ReadFrom(reader);
                        list.AddRange(GenerateFeed(rss.Feed, false));
                    }
                }
            }
            return list;
        }

        private static UpdateCheck CheckForUpdates(string feedUrl, Version currentVersion)
        {
            var r = new UpdateCheck();
            r.Message = "";
            // NOTE: Requires a reference to System.ServiceModel.dll
            var formatter = new Atom10FeedFormatter();
            try
            {
                // Read the feed
                using (var reader = System.Xml.XmlReader.Create(feedUrl))
                {
                    formatter.ReadFrom(reader);

                    var latest = (from i in formatter.Feed.Items
                                  where i.Categories.Any(c => IsStable(c.Name))
                                  orderby i.LastUpdatedTime descending
                                  select i).FirstOrDefault();

                    if (latest != null)
                    {
                        var u = latest.Links.Single().Uri.AbsoluteUri;
                        r.Message += String.Format("The latest release is: {0}\n", u);

                        var update = (from i in formatter.Feed.Items
                                      where ExtractVersion(i.Title.Text) > currentVersion &&
                                      i.Categories.Any(c => IsStable(c.Name))
                                      orderby i.LastUpdatedTime descending
                                      select i).FirstOrDefault();

                        if (update != null)
                        {
                            // TODO: Notify user of available download
                            var downloadUrl = update.Links.Single().Uri.AbsoluteUri;
                            r.Message += String.Format("There is an available update: {0}",
                                                       update.Title.Text);
                            r.UpdateAvailable = true;
                        }
                        else
                        {
                            r.Message += "There is no later version.";
                        }
                    }
                    else
                    {
                        r.Message += "Could not find a later version.";
                    }
                }
            }
            catch (System.Exception exc1)
            {
                r.Message += "Cannot check for updates. " + exc1.ToString();
            }
            return r;
        }

        public static void AtomFeed()
        {
            Atom10FeedFormatter formatter = new Atom10FeedFormatter();
            using (XmlReader reader = XmlReader.Create("https://www.wunschliste.de/xml/atom.pl?user_id=1125047&key=1355167046072"))
            {
                formatter.ReadFrom(reader);
            }

            foreach (SyndicationItem item in formatter.Feed.Items)
            {
                //Console.WriteLine("[{0}][{1}] {2}", item.PublishDate, item.Title.Text, ((TextSyndicationContent)item.Content).Text);
            }

            Console.ReadLine();
        }

        public async Task<Update> CheckForUpdatesAsync(string updateUrl, UpdateFilter updateFilter)
        {
            Contract.Requires(!String.IsNullOrWhiteSpace(updateUrl));

            var reader = XmlReader.Create(updateUrl);
            var formatter = new Atom10FeedFormatter();

            await Task.Factory.StartNew(() => formatter.ReadFrom(reader));

            return (from i in formatter.Feed.Items
                    let u = UpdateHelper.FromSyndicationItem(i)
                    where u.Version > Assembly.GetExecutingAssembly().GetName().Version
                        && ((int)updateFilter & (int)u.ReleaseStatus) != 0
                    orderby u.LastUpdatedTime descending
                    select u).FirstOrDefault();
        }

        private static void ReadFeed(string feedUrl)
        {
            Atom10FeedFormatter formatter = new Atom10FeedFormatter();
            using (XmlReader reader = XmlReader.Create(feedUrl))
            {
                formatter.ReadFrom(reader);
            }

            foreach (SyndicationItem item in formatter.Feed.Items)
            {
                Console.WriteLine("[{0}][{1}]", item.PublishDate, item.Title.Text);
            }

            var prevArchive = formatter.Feed.Links.FirstOrDefault(l => l.RelationshipType == "prev-archive");
            if (prevArchive != null)
            {
                ReadFeed(prevArchive.Uri.ToString());
            }
        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            var MemCache = MemoryCache.Default;

            var Tasks = (IEnumerable<ServiceTask>)MemCache.Get("TaskList");

            if (Tasks == null)
            {
                var formatter = new Atom10FeedFormatter();
                using (XmlReader reader = XmlReader.Create(ConfigurationManager.AppSettings["ServiceApiUrl"]))
                {
                    formatter.ReadFrom(reader);
                }

                MemCache.Add("Organisation", formatter.Feed.Authors.First().Name, new CacheItemPolicy {});

                var Items = formatter.Feed.Items.Select(i => new ServiceTask
                {
                    CategoryId = i.Categories.First().Name,
                    CategoryName = i.Categories.First().Label,
                    Content = ((TextSyndicationContent)i.Content).Text,
                    Details = i.Links.Where(l => l.RelationshipType == "self" && l.MediaType == "application/atom+xml").SingleOrDefault().Uri,
                    Id = i.Id,
                    Summary = i.Summary.Text,
                    Title = i.Title.Text,
                    Updated = i.LastUpdatedTime.DateTime
                });

                MemCache.Add("TaskList", Items, new CacheItemPolicy { });
            }
        }

		public void ReadFrom1 ()
		{
			Atom10FeedFormatter f = new Atom10FeedFormatter ();
			Assert.IsNull (f.Feed, "#1");
			f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><title>test</title></feed>"));
			SyndicationFeed feed1 = f.Feed;
			Assert.IsNotNull (f.Feed.Title, "#2");
			Assert.AreEqual ("test", f.Feed.Title.Text, "#3");
			f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><title>test</title></feed>"));
			Assert.IsFalse (object.ReferenceEquals (feed1, f.Feed), "#4");
		}

        protected static IEnumerable<Contact> GetContacts(ConstantContactCredential credential, Uri requestUri)
        {
            var request = WebRequest.Create(requestUri) as HttpWebRequest;

            if (request == null)
            {
                throw new WebException("Failed to create WebRequest");
            }

            request.Credentials = credential;
            request.Method = "GET";
            request.ContentType = "application/atom+xml";

            var contacts = new List<Contact>();

            // Get response  
            using (var webResponse = request.GetResponse() as HttpWebResponse)
            {
                if (webResponse == null)
                {
                    throw new WebException("Failed to create WebRequest");
                }

                // Get the response stream  
                XmlReader xmlReader = XmlReader.Create(webResponse.GetResponseStream());

                if (webResponse.StatusCode != HttpStatusCode.OK)
                    throw new WebException(webResponse.StatusDescription);

                var atomResponse = new Atom10FeedFormatter();

                if (atomResponse.CanRead(xmlReader))
                {
                    atomResponse.ReadFrom(xmlReader);

                    foreach (SyndicationItem item in atomResponse.Feed.Items)
                    {
                        contacts.Add(new ContactContent(item).Contact);
                    }
                }
            }

            return contacts;
        }

		public void ReadFrom_Language ()
		{
			Atom10FeedFormatter f = new Atom10FeedFormatter ();
			f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='ar-AR'></feed>"));
			Assert.AreEqual ("ar-AR", f.Feed.Language, "#1");
		}

		public void ReadFrom_ImageUrl ()
		{
			Atom10FeedFormatter f = new Atom10FeedFormatter ();
			f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><logo>http://mono-project.com/images/mono.png</logo></feed>"));
			Assert.IsNotNull (f.Feed.ImageUrl, "#1");
			Assert.AreEqual ("http://mono-project.com/images/mono.png", f.Feed.ImageUrl.ToString (), "#2");
		}

		public void ReadFrom_Link ()
		{
			Atom10FeedFormatter f = new Atom10FeedFormatter ();

			f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><link href='urn:foo' rel='enclosure' length='50' type='text/html' wcf='wtf'><extended /></link></feed>"));

			Assert.AreEqual (1, f.Feed.Links.Count, "#1");
			SyndicationLink link = f.Feed.Links [0];
			Assert.AreEqual (50, link.Length, "#2");
			Assert.AreEqual ("urn:foo", link.Uri.ToString (), "#3");
			Assert.AreEqual ("text/html", link.MediaType, "#4");
			Assert.AreEqual ("enclosure", link.RelationshipType, "#5");
			Assert.AreEqual (1, link.AttributeExtensions.Count, "#6");
			Assert.AreEqual (1, link.ElementExtensions.Count, "#7");
		}

		public void ReadFrom_Extension ()
		{
			Atom10FeedFormatter f = new Atom10FeedFormatter ();
			f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><icon>http://www.mono-project.com/icons/mono.png</icon></feed>"));
			Assert.IsNotNull (f.Feed, "#1");
			// 'icon' is treated as an extension ...
			Assert.AreEqual (1, f.Feed.ElementExtensions.Count, "#2");
		}

        private SyndicationFeed GetFeedForMessage(Message message)
        {
            var messageId = message.Id.Value;
            var topicId = message.TopicId;

            var feedEntry = new FeedEntry() { MessageId = messageId, TimeStamp = DateTime.UtcNow };
            var feed = new Feed()
            {
                Entries = new List<FeedEntry>(new[] { feedEntry }),
                Id = Identity.Random(),
                TopicId = topicId,
                Updated = DateTime.UtcNow
            };

            var topic = new Topic()
            {
                Id = topicId,
                Name = "Topic Name",
                Description = "Topic Description",
                GroupId = Identity.Random()
            };

            var key = new MessageKey { MessageId = messageId, TopicId = topicId };

            messageByMessageKey
                .Setup(r => r.Get(It.Is<MessageKey>(k => k.TopicId == key.TopicId && k.MessageId == key.MessageId)))
                .Returns(message);

            getWorkingFeedForTopic
                .Setup(r => r.Execute(topicId))
                .Returns(feed);

            entityById
                .Setup(r => r.Get<Topic>(topicId))
                .Returns(topic);

            var client = new HttpClient(baseUri);

            var response = client.Get(topicId.ToString());
            var formatter = new Atom10FeedFormatter();

            using (var rdr = XmlReader.Create(response.Content.ContentReadStream))
            {
                formatter.ReadFrom(rdr);
                return formatter.Feed;
            }
        }