CommunityServerBlogs/BlogFeedback.cs文件分析

CommunityServerBlogs\BlogFeedback.cs中有如下的一段代码：

/// <summary>
/// Gets the feedback items for the given Weblog
/// </summary>
/// <returns>Returns an ArrayList of FeedBackItem objects.</returns>
public static ArrayList GetFeedback( Int32 weblogID ) 
{
 int outRecords;
 return GetFeedback( weblogID,0,0, out outRecords);
}

 

/// <summary>
/// Gets a paged set of feedback items for the given weblogs
/// </summary>
/// <returns>Returns an ArrayList of FeedBackItem objects.</returns>
public static ArrayList GetFeedback( Int32 blogId, Int32 pageIndex, Int32 pageSize, out Int32 totalRecords ) 
{
 WeblogDataProvider wdp = WeblogDataProvider.Instance();
 return wdp.GetFeedback( blogId,pageIndex, pageSize, out totalRecords);
}

 

可以看到，为了调用者获得一组FeedBack的信息，该文件定义了两个GetFeedback方法，使用第一个方法可以获得所有的记录，使用第二个方法将可以自定义记录的分页。第一个方法中调用第二个方法。因此第二个方法中具有通向底层的接口。这个接口就是WeblogDataProvider类的实例wdp。

在第二个方法中,首先调用 WeblogDataProvider.Instance()静态方法产生一个 WeblogDataProvider类的实例.然后调用该实例的GetFeedback方法来获得记录.
---------------------------------------------
现在看看为什么不直接实例化WeblogDataProvider类而是要调用Instance()静态方法那?

下面是WeblogDataProvider类的代码：

 

//------------------------------------------------------------------------------
// <copyright company="Telligent Systems">
//     Copyright (c) Telligent Systems Corporation.  All rights reserved.
// </copyright> 
//------------------------------------------------------------------------------

using System;
using System.Collections;
using System.Data;
using System.IO;
using System.Xml;
using CommunityServer.Components;
using CommunityServer.Configuration;

namespace CommunityServer.Blogs.Components
{
    /**//// <summary>
    /// Summary description for WeblogDataProvider.
    /// </summary>
    public abstract class WeblogDataProvider
    {
        public static readonly string WeblogDataProviderName = "WeblogDataProvider";

        Search#region Search
        public abstract SearchResultSet GetSearchResults(SearchQuery query, SearchTerms terms);
        public abstract PostSet SearchReindexPosts (int setsize, int settingsID);
        #endregion

        Instance#region Instance

        private static WeblogDataProvider _defaultInstance = null;

        static WeblogDataProvider()
        {
            CreateDefaultCommonProvider();
        }

        /**//// <summary>
        /// Returns an instance of the user-specified data provider class.
        /// </summary>
        /// <returns>An instance of the user-specified data provider class.  This class must inherit the
        /// CommonDataProvider interface.</returns>
        public static WeblogDataProvider Instance() 
        {
            return _defaultInstance;
        }

        public static WeblogDataProvider Instance (Provider dataProvider) 
        {
            WeblogDataProvider fdp = CSCache.Get(dataProvider.Name) as WeblogDataProvider;
            if(fdp == null)
            {
                fdp = DataProviders.Invoke(dataProvider) as WeblogDataProvider;
                CSCache.Max(dataProvider.Name,fdp);
            }
            return fdp;
        }

        /**//// <summary>
        /// Creates the Default CommonDataProvider
        /// </summary>
        private static void CreateDefaultCommonProvider()
        {
            // Get the names of the providers
            //
            CSConfiguration config = CSConfiguration.GetConfig();

            // Read the configuration specific information
            // for this provider
            //
            Provider sqlForumsProvider = (Provider) config.Providers[WeblogDataProviderName];

            // Read the connection string for this provider
            //
            
            _defaultInstance = DataProviders.CreateInstance(sqlForumsProvider) as WeblogDataProvider;
        }
        
        #endregion

        Base Methods#region Base Methods

        Get Posts#region Get Posts
        public abstract WeblogPost GetWeblogPost(int postID, bool includeCategories, bool isApproved);
        public abstract ThreadSet GetBlogThreads(BlogThreadQuery query);
        public abstract PostSet GetPosts(BlogPostQuery query);
        public abstract PostSet GetThreadsTrackedByUser(int SectionID, int UserID);
        #endregion

        Posts#region Posts
        public abstract BlogPostResults AddPost(WeblogPost post, User user, out int PostID);
        public abstract BlogPostResults UpdatePost(WeblogPost post, int editedBy);
        public abstract void DeletePost(int sectionID, int postID, int userID, BlogPostType blogPostType);
        #endregion

        GetBlogs#region GetBlogs
        public abstract Hashtable GetWeblogs();
        #endregion

        Permissions#region Permissions
        public abstract ArrayList GetBlogPermissions(int weblogID);
        #endregion

        Blog Feedback#region Blog Feedback

        public abstract ArrayList GetFeedback( Int32 forumID, Int32 pageIndex, Int32 pageSize, out Int32 totalRecords );

        #endregion

        public abstract ArrayList GetPostsByMonths(int BlogID);
        public abstract Hashtable GetPostsByMonth(int BlogID, DateTime Month);

        public abstract void UpdateRecentContent(int SettingsID);
        public abstract void WeblogPostToForumPost(int postID, int forumID, int SettingsID);

        #endregion

        Helpers#region Helpers

        public static object ConvertCategoriesToXML(string[] Categories)
        {
            if(Categories == null || Categories.Length == 0)
                return DBNull.Value;

            StringWriter sw = new StringWriter();
            XmlTextWriter writer = new XmlTextWriter(sw);
            writer.WriteStartElement("Categories");
            foreach (string category in Categories)
            {
                writer.WriteElementString("Category", category);
            }
            writer.Close();
            return sw.ToString();
        }

        #endregion

        Populate#region Populate

        Weblogs#region Weblogs

        /**//// <summary>
        /// Populates an existing Weblog object
        /// </summary>
        public static void PopulateWeblogData(IDataReader dr, Weblog w)
        {
            CommonDataProvider.PopulateSectionFromIDataReader(dr,w);

            w.MostRecentPostName = dr["MostRecentPostName"] as string;

            w.MostRecentArticleID = (int)dr["MostRecentArticleID"];
            w.MostRecentArticleDate = (DateTime)dr["MostRecentArticleDate"];
            w.MostRecentArticleAuthor = dr["MostRecentArticleAuthor"] as string;
            w.MostRecentArticleAuthorID = (int)dr["MostRecentArticleAuthorID"];
            w.MostRecentArticleName = dr["MostRecentArticleName"] as string;
           
            w.PostCount = (int)dr["PostCount"];
            w.ArticleCount = (int)dr["ArticleCount"];
            w.TrackbackCount = (int)dr["TrackbackCount"];
            w.CommentCount = (int)dr["CommentCount"];
        }

        #endregion


        public static WeblogPost PopulateWeblogPostContentFromIDataReader(IDataReader reader) 
        {
            //Is this all of the data we need?
            WeblogPost post = new WeblogPost();


            post.SectionID =                (int) reader["SectionID"];
            post.PostID =                    (int) reader["PostID"];
            post.Replies =                (int) reader["Replies"];
            post.Views =                  (int) reader["TotalViews"];
            post.AggViews =                  (int) reader["AggViews"];
            post.ThreadID =               (int) reader["ThreadID"];
            post.Subject =                (string) reader["Subject"];
            post.Body =                   (string) reader["Body"];
            post.Username =               (string) reader["Username"];
            post.AuthorID =                  (int) reader["UserID"];
            post.PostDate =               (DateTime) reader["PostDate"];
            post.BloggerTime =               (DateTime) reader["BloggerTime"];
            post.ThreadDate =             (DateTime) reader["ThreadDate"];
            post.IsLocked =               (bool) reader["IsLocked"];
            post.IsApproved =             (bool) reader["IsApproved"];
            post.FormattedBody =           reader["FormattedBody"] as string;
            post.ThreadID = (int)reader["ThreadID"];

            post.PostLevel =        (int) reader["PostLevel"];
            post.ParentID = (int) reader["ParentID"];

            post.PostConfig =              (BlogPostConfig) (int)reader["PostConfig"];
            post.BlogPostType =            (BlogPostType) (byte)reader["BlogPostType"];

            post.TitleUrl =                reader["TitleUrl"] as string;
            post.Excerpt =                 reader["Excerpt"] as string;
            post.Name =                    reader["PostName"] as string;

            post.RatingSum = (int)reader["RatingSum"];
            post.TotalRatings = (int)reader["TotalRatings"];

            return post;
        }

        public static WeblogPost PopulateWeblogPostContentFromDataRow(DataRow dr, DataRelation relationShip) 
        {
            //Is this all of the data we need?
            WeblogPost post = new WeblogPost();


            post.SectionID =                (int) dr["SectionID"];
            post.PostID =                    (int) dr["PostID"];
            post.Replies =                (int) dr["Replies"];
            post.Views =                  (int) dr["TotalViews"];
            post.AggViews =                  (int) dr["AggViews"];
            post.ThreadID =               (int) dr["ThreadID"];
            post.Subject =                (string) dr["Subject"];
            post.Body =                   (string) dr["Body"];
            post.Username =               (string) dr["Username"];
            post.AuthorID =                  (int) dr["UserID"];
            post.PostDate =               (DateTime) dr["PostDate"];
            post.BloggerTime =               (DateTime) dr["BloggerTime"];
            post.ThreadDate =             (DateTime) dr["ThreadDate"];
            post.IsLocked =               (bool) dr["IsLocked"];
            post.EmoticonID =             (int) dr["ThreadEmoticonID"];
            post.FormattedBody =           dr["FormattedBody"] as string;

            post.IsApproved =             (bool) dr["IsApproved"];


            post.PostLevel =        (int) dr["PostLevel"];
            post.ParentID = (int) dr["ParentID"];

            post.PostConfig =              (BlogPostConfig) (int)dr["PostConfig"];
            post.BlogPostType =             (BlogPostType) (byte)dr["BlogPostType"];

            post.TitleUrl =                dr["TitleUrl"] as string;
            post.Excerpt =                 dr["Excerpt"] as string;
            post.Name =                    dr["PostName"] as string;

            post.RatingSum = (int)dr["RatingSum"];
            post.TotalRatings = (int)dr["TotalRatings"];

            DataRow[] categories = dr.GetChildRows(relationShip);
            if(categories != null && categories.Length > 0)
            {
                post.Categories = new string[categories.Length];
                for(int i = 0; i<categories.Length; i++)
                {
                    post.Categories[i] = categories[i]["Name"] as string;
                }
            }

            return post;
        }


        public static WeblogPost PopulateWeblogEntryFromIDataReader(IDataReader reader) 
        {
            WeblogPost entry = PopulateWeblogPostContentFromIDataReader(reader);
            SerializerData data = CommonDataProvider.PopulateSerializerDataIDataReader(reader, SerializationType.Post);
            entry.SetSerializerData(data);

            return entry;


//            CommonDataProvider.PopulatePostFromIDataReader(reader,entry);
//
//            entry.PostConfig = (BlogPostConfig) (int)reader["PostConfig"];
//            entry.BlogPostType = (BlogPostType) (byte)reader["BlogPostType"];
//
//            entry.BloggerTime = (DateTime) reader["BloggerTime"];
//
//            entry.TitleUrl = reader["TitleUrl"] as string;
//            entry.Excerpt = reader["Excerpt"] as string;
//            entry.Name = reader["PostName"] as string;
//
//            entry.RatingSum = (int)reader["RatingSum"];
//            entry.TotalRatings = (int)reader["TotalRatings"];
        }



        #endregion

    }
}

 

看了一下晕了，竟然是抽象类，竟然可以直接调用里面的Instrance()方法．
再看看这个Instance()方法：

private static WeblogDataProvider _defaultInstance = null;

 

public static WeblogDataProvider Instance() 
{
    return _defaultInstance;
}

 

静态方法竟然可以返回类中的静态变量，这个静态变量初始值是null,
在哪里初始化的那？看看这个线索：

static WeblogDataProvider()
{
    CreateDefaultCommonProvider();
}

 

/// <summary>
/// Creates the Default CommonDataProvider
/// </summary>
private static void CreateDefaultCommonProvider()
{
    // Get the names of the providers
    //
    CSConfiguration config = CSConfiguration.GetConfig();

    // Read the configuration specific information
    // for this provider
    //
    Provider sqlForumsProvider = (Provider) config.Providers[WeblogDataProviderName];

    // Read the connection string for this provider
    //
    
    _defaultInstance = DataProviders.CreateInstance(sqlForumsProvider) as WeblogDataProvider;
}

 

可以看到，_defaultInstance是在构造函数中被初始化的．
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
至此，有两个问题：
1. 构造函数竟然也写成静态的，作用是什么？
2. 没有加public , 那么这个方法是公有的还是私有的
3. 那么这个_defaultInstance是什么时候被初始化的那？

--------------------------------------------------------------------------------------
关于第1个问题，我自己的理解是：
   既然_defaultInstance是静态成员，那么一旦被初始化以后，将会一直保持到当前Application的终止。
所以以后就不用再初始化了。但是为什么要采用这种方式，为什么不采用SingleTon模式，或者说这种写法就是SingleTon模式的变种？

关于第2个问题，msdn中的论述如下：
  任何未显式声明的成员均默认为 Public，但字段或常量除外，它们默认为 Private
由此可见，WeblogDataProvider()这个构造函数是公共(public)的。

关于第3个问题，我在整个解决方案中查找WeblogDataProvider关键字。发现没有一个方法调用WeblogDataProvider()构造函数，
但是，却有很多调用Instance()方法的语句，难道静态的构造函数会自动执行吗？