rssreader.cs

1.left.aspx下部分实现了读取RDF（RDF format feeds

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Xml;
using System.IO;
using System.Collections;
using System.Data.Sql;
using System.Data.SqlClient;

namespace Sloppycode.net
{
    #region About DataBase
    public class AboutData
    {
        String connStr = @"Data Source=6998D47256954C1\SQLEXPRESS;Initial Catalog=rss;Integrated Security=True";
//        String connStr = ConfigurationSettings.AppSettings["rssConnectionString"];

        // 绑定DropDownList
        public void BindDropDownList(DropDownList ddl)
        {
            SqlConnection conn = new SqlConnection(connStr);
            string strSql = "select FeedID,Title,url,UpdateInterval from Feeds";
            SqlDataAdapter sda = new SqlDataAdapter(strSql, conn);
            DataSet ds = new DataSet();
            sda.Fill(ds,"Feeds");
            ddl.DataSource = ds.Tables["Feeds"].DefaultView;
            ddl.DataTextField = "Title";
            ddl.DataValueField = "url";
            ddl.DataBind();
        }

        // 获取Feeds
        public SqlDataReader getFeeds()
        {
            SqlConnection conn = new SqlConnection(connStr);
            SqlCommand comm = new SqlCommand();
            comm.Connection = conn;
            comm.CommandType = CommandType.Text;
            comm.CommandText = "Select * From Feeds";
            conn.Open();
            return comm.ExecuteReader(CommandBehavior.CloseConnection);
        }

        // 装载Top页面
        public XmlDocument loadTop(int feedID)
        {
            SqlConnection conn = new SqlConnection(connStr);
            string strSql = "select url,UpdateInterval from Feeds where feedid=@feedID";
            SqlCommand comm = new SqlCommand(strSql, conn);
            SqlParameter sp = new SqlParameter("@feedid", SqlDbType.Int, 4);
            sp.Value = feedID;
            comm.Parameters.Add(sp);

            conn.Open();
            string url = comm.ExecuteScalar().ToString();
            conn.Close();

            XmlDocument xml = new XmlDocument();
            xml.Load(url);

            return xml;
        }
    }
    #endregion

    #region Event datatype/delegate
    // 装在和解析 RSS feed期间发生错误
    public class RssReaderErrorEventArgs : EventArgs
    {
        private string message;

        // 错误细节
        public string Message
        {
            get
            {
                return this.message;
            }
            set
            {
                this.message = value;
            }
        }
    }

    // 声名处理 RssReader错误事件的方法
    public delegate void RssReaderErrorEventHandler(object sender, RssReaderErrorEventArgs e);
    #endregion

    #region RssReader类
    /// <summary>
    /// RssReader 的摘要说明
    /// </summary>
    public class RssReader
    {
        // 成员
        private string rootNodeName = "rss";
        private string channelNodeName = "channel";
        private bool rdfMode = false;

        // 事件包括：XML 文档装载，rss 元素的发现，channel 结点的发现，解析项目，错误

        public RssReader()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }

        // 完成 feed从提供的 url到XML 剖析器到装载
        public event EventHandler FeedLoaded;

        // 在 feed中点找到根节点（rss）
        public event EventHandler RssNodeFound;

        // 在 feed中找到 rss节点的子节点（channel）
        public event EventHandler ChannelNodeFound;

        // item被添加
        public event EventHandler ItemAdded;

        // 装载或解析 feed发生错误
        public event RssReaderErrorEventHandler Error;

        // RSS feed中 rss元素节点名字，默认为'rss'
        public string RootNodeName
        {
            get
            {
                return this.rootNodeName;
            }
            set
            {
                this.rootNodeName = value;
            }
        }

        // RSS feed中 channel元素节点名字，默认为'channel'
        public string ChannelNodeName
        {
            get
            {
                return this.channelNodeName;
            }
            set
            {
                this.channelNodeName = value;
            }
        }

        // 完整的 RDF是不支持的，但RSS中拥有相应RDF诸如channel的description,title,以及各item的title,description
        // 属性的items是匹配的
        public bool RdfMode
        {
            get
            {
                return this.rdfMode;
            }
            set
            {
                if (value)
                {
                    this.rootNodeName = "rdf:RDF";
                }
                else
                {
                    this.rootNodeName = "rss";
                }
                this.rdfMode = value;
            }
        }

        // 利用提供的url获得RssFeed
        public static RssFeed GetFeed(string Url, bool RdfFormat)
        {
            RssReader rssReader = new RssReader();
            rssReader.rdfMode = RdfFormat;
            return rssReader.Retrieve(Url);
        }

        // 利用提供的url获得RssFeed
        public static RssFeed GetFeed(string Url)
        {
            RssReader rssReader = new RssReader();
            return rssReader.Retrieve(Url);
        }
        
        // 从RSS feed创建HTML
        public static string CreateHtml(RssFeed Feed, string Template, string ItemPrefix, string ItemSuffix)
        {
            return new RssHtmlMaker().GetHtmlContents(Feed, Template, ItemPrefix, ItemSuffix);
        }

        public static string CreateHtml(RssFeed Feed, string Template, string ItemPrefix, string ItemSuffix, int MaxItems)
        {
            RssHtmlMaker rssHtmlMaker = new RssHtmlMaker();
            rssHtmlMaker.MaxItems = MaxItems;
            return rssHtmlMaker.GetHtmlContents(Feed, Template, ItemPrefix, ItemSuffix);
        }

        // 根据给定的Url获取RSS feed，解析后创建新的RssFeed对象
        public RssFeed Retrieve(string Url)
        {
            RssFeed rssFeed = new RssFeed();
            rssFeed.Items = new RssItems();

            XmlTextReader xmlTextReader = new XmlTextReader(Url);
            XmlValidatingReader xmlValidatingReader = new XmlValidatingReader(xmlTextReader);
            xmlValidatingReader.ValidationType = ValidationType.None;

            XmlDocument xmlDoc = new XmlDocument();

            try
            {
                xmlDoc.Load(xmlTextReader);

                // Fire load事件
                if (this.FeedLoaded != null)
                {
                    this.FeedLoaded(this, new EventArgs());
                }

                XmlNode rssXmlNode = null;

                // 循环子节点直到找到rss节点为止
                for (int i = 0; i < xmlDoc.ChildNodes.Count; i++)
                {
                    System.Diagnostics.Debug.Write("Child: " + xmlDoc.ChildNodes[i].Name);
                    System.Diagnostics.Debug.WriteLine(" has " + xmlDoc.ChildNodes[i].ChildNodes.Count + " children");

                    if (xmlDoc.ChildNodes[i].Name == this.rootNodeName && xmlDoc.ChildNodes[i].ChildNodes.Count > 0)
                    {
                        rssXmlNode = xmlDoc.ChildNodes[i];

                        // Fire found事件
                        if (this.RssNodeFound != null)
                        {
                            this.RssNodeFound(this, new EventArgs());
                        }

                        break;
                    }
                }

                if (rssXmlNode != null)
                {
                    XmlNode channelXmlNode = null;

                    // 循环rss节点直到发现channel
                    for (int i = 0; i < rssXmlNode.ChildNodes.Count; i++)
                    {
                        System.Diagnostics.Debug.WriteLine("Rss child: " + rssXmlNode.ChildNodes[i].Name);
                        if (rssXmlNode.ChildNodes[i].Name == this.channelNodeName && rssXmlNode.ChildNodes[i].ChildNodes.Count > 0)
                        {
                            channelXmlNode = rssXmlNode.ChildNodes[i];

                            // Fire found事件
                            if (this.ChannelNodeFound != null)
                            {
                                this.ChannelNodeFound(this, new EventArgs());
                            }

                            break;
                        }
                    }

                    // 找到channel节点
                    if (channelXmlNode != null)
                    {
                        // 在它的孩子中循环，将详细信息拷贝到RssFeed结构，并解析items
                        for (int i = 0; i < channelXmlNode.ChildNodes.Count; i++)
                        {
                            System.Diagnostics.Debug.WriteLine(channelXmlNode.ChildNodes[i].Name);
                            switch (channelXmlNode.ChildNodes[i].Name)
                            {
                                case "title":
                                    {
                                        rssFeed.Title = channelXmlNode.ChildNodes[i].InnerText;
                                        break;
                                    }
                                case "description":
                                    {
                                        rssFeed.Description = channelXmlNode.ChildNodes[i].InnerText;
                                        break;
                                    }
                                case "language":
                                    {
                                        rssFeed.Language = channelXmlNode.ChildNodes[i].InnerText;
                                        break;
                                    }
                                case "copyright":
                                    {
                                        rssFeed.Copyright = channelXmlNode.ChildNodes[i].InnerText;
                                        break;
                                    }
                                case "webmaster":
                                    {
                                        rssFeed.Webmaster = channelXmlNode.ChildNodes[i].InnerText;
                                        break;
                                    }
                                case "pubDate":
                                    {
                                        rssFeed.PubDate = channelXmlNode.ChildNodes[i].InnerText;
                                        break;
                                    }
                                case "lastBuildDate":
                                    {
                                        rssFeed.LastBuildDate = channelXmlNode.ChildNodes[i].InnerText;
                                        break;
                                    }
                                case "category":
                                    {
                                        rssFeed.Category = channelXmlNode.ChildNodes[i].InnerText;
                                        break;
                                    }
                                case "generator":
                                    {
                                        rssFeed.Generator = channelXmlNode.ChildNodes[i].InnerText;