private async Task <ISyndicationCategory> ReadCategory(Rss20FeedReader reader)
        {
            ISyndicationCategory category = null;

            category = await reader.ReadCategory();

            return(category);
        }
        private async Task <ISyndicationLink> ReadLink(Rss20FeedReader reader)
        {
            ISyndicationLink link = null;

            link = await reader.ReadLink();

            return(link);
        }
        private async Task <ISyndicationImage> ReadImage(Rss20FeedReader reader)
        {
            ISyndicationImage image = null;

            image = await reader.ReadImage();

            return(image);
        }
        private async Task <ISyndicationPerson> ReadPerson(Rss20FeedReader reader)
        {
            ISyndicationPerson person = null;

            person = await reader.ReadPerson();

            return(person);
        }
        private async Task <ISyndicationItem> ReadItem(Rss20FeedReader reader)
        {
            ISyndicationItem item = null;

            if (_sizeOfItem == 0)
            {
                //The size of the item has not been read.
                ISyndicationContent content = await reader.ReadContent();

                //_sizeOfItem = Encoding.UTF8.GetByteCount(content.RawContent);
                _sizeOfItem = 291; // content.RawContent.Length;

                Rss20FeedParser parser = reader.Parser as Rss20FeedParser;
                item = parser.CreateItem(content);
            }
            else
            {
                item = await reader.ReadItem();
            }

            return(item);
        }
        public async Task ConsumeFeed(string filePath)
        {
            bool verbose = false;

            // Information to display.
            double size        = new FileInfo(filePath).Length;
            double currentSize = 0;
            int    itemsRead   = 0;

            // Transform the size of the file to Kb - Mb - Gb.
            Tuple <double, string> sizeInfo = utils.ConvertBytesToSize(size);

            // Display the Size of the feed and ask for verbose.
            Console.ForegroundColor = ConsoleColor.DarkGreen;
            Console.WriteLine("Size of the Feed: {0:N2} {1}", sizeInfo.Item1, sizeInfo.Item2);
            Console.Write("Verbose Items (Y/N): ");

            Console.ForegroundColor = ConsoleColor.White;
            string input = Console.ReadLine();

            verbose = utils.ValidateVerbose(input);
            Console.CursorVisible = false;
            Stopwatch stopWatch = null;

            using (var xmlReader = XmlReader.Create(filePath, new XmlReaderSettings()
            {
                Async = true
            }))
            {
                var reader = new Rss20FeedReader(xmlReader);
                stopWatch = new Stopwatch();
                stopWatch.Start();
                ElementDisplayer displayer = new ElementDisplayer();

                while (await reader.Read())
                {
                    if (verbose)
                    {
                        utils.ClearInformation();
                    }

                    switch (reader.ElementType)
                    {
                    case SyndicationElementType.Content:
                        ISyndicationContent content = await reader.ReadContent();

                        if (verbose)
                        {
                            displayer.DisplayContent(content);
                        }
                        break;

                    case SyndicationElementType.Item:
                        ISyndicationItem item = await ReadItem(reader);

                        itemsRead++;
                        if (verbose)
                        {
                            displayer.DisplayItem(item);
                        }
                        currentSize += _sizeOfItem;
                        break;

                    case SyndicationElementType.Person:
                        ISyndicationPerson person = await ReadPerson(reader);

                        if (verbose)
                        {
                            displayer.DisplayPerson(person);
                        }
                        break;

                    case SyndicationElementType.Image:
                        ISyndicationImage image = await ReadImage(reader);

                        if (verbose)
                        {
                            displayer.DisplayImage(image);
                        }
                        break;

                    case SyndicationElementType.Link:
                        ISyndicationLink link = await ReadLink(reader);

                        if (verbose)
                        {
                            displayer.DisplayLink(link);
                        }
                        break;

                    case SyndicationElementType.Category:
                        ISyndicationCategory category = await ReadCategory(reader);

                        if (verbose)
                        {
                            displayer.DisplayCategory(category);
                        }
                        break;
                    }

                    double percentage = ((currentSize * 100) / size);

                    if (itemsRead % 200 == 0)
                    {
                        utils.WriteInformation(percentage, itemsRead, stopWatch.Elapsed);
                    }
                }
            }
            utils.ClearInformation();

            //Print end of reading
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Finished Reading, press enter to close.\n\n");
            utils.WriteInformation(100, itemsRead, stopWatch.Elapsed);
            Console.ReadLine();
        }
        public static async Task ReadFeed()
        {
            using (XmlReader xmlReader = XmlReader.Create(@"..\DemoTest1\TestFeeds\rss20.xml", new XmlReaderSettings()
            {
                Async = true
            }))
                using (XmlWriter xmlWriter = XmlWriter.Create(Console.Out, new XmlWriterSettings()
                {
                    Indent = true, Async = true
                }))
                {
                    Rss20FeedReader reader = new Rss20FeedReader(xmlReader);
                    Rss20FeedWriter writer = new Rss20FeedWriter(xmlWriter);

                    while (await reader.Read())
                    {
                        switch (reader.ElementType)
                        {
                        case SyndicationElementType.Category:
                            ISyndicationCategory category = await reader.ReadCategory();

                            await writer.Write(category);

                            break;

                        case SyndicationElementType.Image:
                            ISyndicationImage image = await reader.ReadImage();

                            await writer.Write(image);

                            break;

                        case SyndicationElementType.Item:
                            ISyndicationItem item = await reader.ReadItem();

                            await writer.Write(item);

                            break;

                        case SyndicationElementType.Link:
                            ISyndicationLink link = await reader.ReadLink();

                            await writer.Write(link);

                            break;

                        case SyndicationElementType.Person:
                            ISyndicationPerson person = await reader.ReadPerson();

                            await writer.Write(person);

                            break;

                        default:
                            ISyndicationContent content = await reader.ReadContent();

                            await writer.Write(content);

                            break;
                        }

                        xmlWriter.Flush();
                        // Simulate a slow stream.
                        Thread.Sleep(300);
                    }
                }
        }