博客园_Winson的博客天空

.Net插件框架的实现及分析（三）

2011-09-29T02:51:00Z

.Net插件框架的实现及分析导航

话接上回（.Net插件框架的实现及分析（二）)，这次我想讨论下的是如何使用之前建立的框架来创建一个插件。现在我们主要以格式化插件为例，因此准备创建一个代码高亮的插件，在发表文章时，可以插入相关的代码语法高亮功能，以下实现的插件修改自Screwturn Wiki's 的 SyntaxHighlight 插件，所在一些不太重要的代码中的英文注释我就不一一翻译了，只为说明如何配置此框架使用。

此代码高亮插件使用的也是SyntaxHighlight JS版的插件，在此就不再多作介绍了，相必大家都应该知道。OK，接下来就直接说代码了：

因为一个插件最终需要生成一个独立的DLL文件，因此我们需要先建立一个新的插件项目，就名为：CoderBlog.Plugin.SyntaxHighlighter

此语法高亮插件包含了2个类，一个专门处理程序语言的，此为辅助类：

Languages.cs文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/// 此插件修改自原 Screwturn Wiki's  的 SyntaxHighlight 插件，在此只作演示代码用，原插件地址
/// http://greenicicleblog.com/ScrewTurnSyntaxHighlighter
/// 此类只是本插件的一个辅助类，以下英文注释我就不翻译了，都不难的，呵。

namespace CoderBlog.Plugin.SyntaxHighlighter
{
    public class Languages
    {
        private Dictionary<string, string> m_Brushes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

        /// <summary>
        /// Constructor. When a Languages class is created,
        /// a list of predefined languages ("brushes") is created.
        /// </summary>
        public Languages()
        {
            InitializeBrushes();
        }

        /// <summary>
        /// Returns if a programming language is supported by the formatter.
        /// If there is a brush for it, a language is supported.
        /// </summary>
        /// <param name="language">The programming language name to test.</param>
        /// <returns><c>true</c> if the provided language is supported,
        /// otherwise, <c>false.</c></returns>
        public bool IsSupported(string language)
        {
            if (string.IsNullOrEmpty(language))
            {
                throw new ArgumentNullException("language");
            }
            string key = language.Trim();
            return m_Brushes.ContainsKey(key);
        }

        /// <summary>
        /// Returns the brush CSS file for a programming language.
        /// </summary>
        /// <param name="language">The programming language name.</param>
        /// <returns>The name of a brush CSS file, or <c>null</c>
        /// if the language is not supported.</returns>
        public string GetStylesheetFile(string language)
        {
            if (string.IsNullOrEmpty(language))
            {
                throw new ArgumentNullException("language");
            }

            string stylesheetFile;
            string key = language.Trim();
            m_Brushes.TryGetValue(key, out stylesheetFile);
            return stylesheetFile;
        }

        /// <summary>
        /// Adds a user-defined language brush to the set of supported languages.
        /// </summary>
        /// <param name="language">The name of the language, as given as the first word in a code block</param>
        /// <param name="stylesheetFile">Name of the additional language ("brush") javascript file
        /// within the syntax hightlighter directory.</param>
        public void AddLanguage(string language, string stylesheetFile)
        {
            if (string.IsNullOrEmpty(language))
            {
                throw new ArgumentNullException("language");
            }
            if (string.IsNullOrEmpty(stylesheetFile))
            {
                throw new ArgumentNullException("stylesheetFile");
            }
            m_Brushes[language.ToLowerInvariant()] = stylesheetFile;
        }

        /// <summary>
        /// Initializes the list of supported language names and associates them
        /// with a brush style sheet.
        /// </summary>
        private void InitializeBrushes()
        {
            m_Brushes.Add("as3", "shBrushAS3.js");
            m_Brushes.Add("actionscript3", "shBrushAS3.js");
            m_Brushes.Add("bash", "shBrushBash.js");
            m_Brushes.Add("shell", "shBrushBash.js");
            m_Brushes.Add("cf", "shBrushColdFusion.js");
            m_Brushes.Add("coldfusion", "shBrushColdFusion.js");
            m_Brushes.Add("c-sharp", "shBrushCSharp.js");
            m_Brushes.Add("csharp", "shBrushCSharp.js");

            m_Brushes.Add("cpp", "shBrushCpp.js");
            m_Brushes.Add("c", "shBrushCpp.js");
            m_Brushes.Add("css", "shBrushCss.js");
            m_Brushes.Add("delphi", "shBrushDelphi.js");
            m_Brushes.Add("pas", "shBrushDelphi.js");
            m_Brushes.Add("pascal", "shBrushDelphi.js");
            m_Brushes.Add("diff", "shBrushDiff.js");
            m_Brushes.Add("patch", "shBrushDiff.js");
            m_Brushes.Add("erl", "shBrushErlang.js");
            m_Brushes.Add("erlang", "shBrushErlang.js");
            m_Brushes.Add("groovy", "shBrushGroovy.js");
            m_Brushes.Add("js", "shBrushJScript.js");
            m_Brushes.Add("jscript", "shBrushJScript.js");
            m_Brushes.Add("javascript", "shBrushJScript.js");
            m_Brushes.Add("java", "shBrushJava.js");
            m_Brushes.Add("jfx", "shBrushJavaFX.js");
            m_Brushes.Add("javafx", "shBrushJavaFX.js");
            m_Brushes.Add("pl", "shBrushPerl.js");
            m_Brushes.Add("perl", "shBrushPerl.js");
            m_Brushes.Add("php", "shBrushPhp.js");
            m_Brushes.Add("plain", "shBrushPlain.js");
            m_Brushes.Add("text", "shBrushPlain.js");
            m_Brushes.Add("ps", "shBrushPowerShell.js");
            m_Brushes.Add("powershell", "shBrushPowerShell.js");
            m_Brushes.Add("py", "shBrushPython.js");
            m_Brushes.Add("python", "shBrushPython.js");
            m_Brushes.Add("rails", "shBrushRuby.js");
            m_Brushes.Add("ror", "shBrushRuby.js");
            m_Brushes.Add("ruby", "shBrushRuby.js");
            m_Brushes.Add("scala", "shBrushScala.js");
            m_Brushes.Add("sql", "shBrushSql.js");
            m_Brushes.Add("vb", "shBrushVb.js");
            m_Brushes.Add("vbnet", "shBrushVb.js");
            m_Brushes.Add("xml", "shBrushXml.js");
            m_Brushes.Add("xhtml", "shBrushXml.js");
            m_Brushes.Add("html", "shBrushXml.js");
            m_Brushes.Add("xslt", "shBrushXml.js");
            m_Brushes.Add("xaml", "shBrushXml.js");

        }
    }
}

接下来就要实现具体的插件类了，此类必须继承自我们之前创建的格式化接口 IFormatterProvider，由于已有了 IHost 主程序的接口，所以插件项目只需引用一个 CoderBlog.PluginFramework 项目即可了，不需直接与主程序接触：

SyntaxHighlighter.cs 文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using CoderBlog.PluginFramework;

/// 此插件修改自原 Screwturn Wiki's  的 SyntaxHighlight 插件，在此只作演示代码用，原插件地址
/// http://greenicicleblog.com/ScrewTurnSyntaxHighlighter

namespace CoderBlog.Plugin.SyntaxHighlighter
{
    /// <summary>
    /// 添加语法高亮效果
    /// </summary>
    /// <remarks>
    /// <para>
    /// 支持定义默认语言
    /// </para>
    /// <example>
    /// 以下为使用示例：
    /// 使用 @@ Languages 开始,并以 @@ 为结束
    /// <code>
    /// @@ csharp
    /// public const string WebSiteURL="http://www.CoderBlog.in";
    /// @@
    /// </code>
    /// </example>
    /// </remarks>
    public class SyntaxHighlighter : IFormatterProvider
    {

        IHost host;

        /// <summary>
        /// 设置插件信息
        /// </summary>
        private static readonly PluginInfo info = new PluginInfo("SyntaxHighlighter Plugin", "Winson", "1.0.0.0", "http://www.CoderBlog.in", "http://www.CoderBlog.in/download/Plugins/SyntaxHighlighter.txt");

        private string m_ConfigurationString;
        private string m_ClientScriptBaseUrl;
        // 准备一个程序语言代码列表变量
        IList<string> foundLanguages = new List<string>();

        /// <summary>
        /// 客户端代码的 URL
        /// JavaScript and CSS files.
        /// </summary>
        protected internal string ClientScriptBaseUrl
        {
            get
            {
                string baseUrl = m_ClientScriptBaseUrl ?? DefaultClientScriptBaseUrl;
                if (!baseUrl.EndsWith("/"))
                {
                    baseUrl = baseUrl + "/";
                }
                return baseUrl;
            }
            set
            {
                m_ClientScriptBaseUrl = value;
            }
        }

        /// <summary>
        /// 设置获取默认语言
        /// </summary>
        protected internal string DefaultLanguage
        {
            get;
            set;
        }

        /// <summary>
        /// 语言的主题
        /// </summary>
        protected internal string Theme
        {
            get;
            set;
        }
        /// <summary>
        /// 创建新的语法高亮实例
        /// </summary>
        public SyntaxHighlighter()
        {
            // 设置默认值
            DefaultLanguage = "text";
            Theme = "Default";
            Languages = new Languages();
        }

        /// <summary>
        /// 解析语言名称 (如 "csharp" 或 "html") 到对应的 javascript 文件
        /// </summary>
        protected internal Languages Languages
        {
            get;
            private set;
        }

        /// <summary>
        /// 默认的客户端脚本路径
        /// </summary>
        public const string DefaultClientScriptBaseUrl = "~/Plugins/SyntaxHighlighter/";

        /// <summary>
        /// 语法高亮的起始标签
        /// </summary>
        protected internal const string CodeBlockTag = "<pre>";

        /// <summary>
        /// 配置文件的文本
        /// </summary>
        protected internal string ConfigurationString
        {
            get
            {
                return m_ConfigurationString;
            }
            set
            {
                m_ConfigurationString = value;

                //此处可通过主程序读取配置文件信息，在此就不作详细代码了，请自行实现，
                //其实只是读取文本文件的配置，当然你也可以用XML，以下代码就先注释掉了

                //Dictionary<string, string> config = host.ReadProviderConfiguration(m_ConfigurationString);
                //ClientScriptBaseUrl = config["scripturl"];
                //Theme = config["theme"];
                //DefaultLanguage = config["defaultlang"];
                //string customlang = config["customlang"];
                ////添加自定义语言
                //foreach (string option in customlang.Split('|'))
                //{
                //    string[] parts = option.Split(':');
                //    if (parts.Length == 2)
                //    {
                //        string key = parts[0].Trim();
                //        string val = parts[1].Trim();
                //        if (!string.IsNullOrEmpty(key))
                //        {
                //            Languages.AddLanguage(key, val);
                //        }
                //    }
                //}
            }
        }

        #region 扩展方法，以下注释我也不一一说明啦，英文都很简单，大家自己看看吧
        /// <summary>
        /// Appends the reference to a CSS style sheet to the formatted text.
        /// </summary>
        /// <param name="textBuilder"><see cref="StringBuilder"/> that creates the formatted text.</param>
        /// <param name="styleSheetName">File name of the style sheet.</param>
        protected internal virtual void AppendStyleSheet(StringBuilder textBuilder, string styleSheetName)
        {
            textBuilder.Append("<link href='");
            textBuilder.Append(ClientScriptBaseUrl);
            textBuilder.Append("styles/");
            textBuilder.Append(styleSheetName);
            textBuilder.Append("' rel='stylesheet' type='text/css'/>\n");
        }

        /// <summary>
        /// Appends the reference to a client-side script to the formatted text.
        /// </summary>
        /// <param name="textBuilder"><see cref="StringBuilder"/> that creates the formatted text.</param>
        /// <param name="scriptName">File name of the script.</param>
        protected internal virtual void AppendClientScript(StringBuilder textBuilder, string scriptName)
        {
            textBuilder.Append("<script src='");
            textBuilder.Append(ClientScriptBaseUrl);
            textBuilder.Append("scripts/");
            textBuilder.Append(scriptName);
            textBuilder.Append("' type='text/javascript'></script>\n");
        }

        /// <summary>
        /// Appends the reference to a programming language specific
        /// script ("brush") to the formatted text
        /// </summary>
        /// <param name="textBuilder"><see cref="StringBuilder"/> that creates the formatted text.</param>
        /// <param name="language">The language.</param>
        protected internal virtual void AppendBrushScript(StringBuilder textBuilder, string language)
        {
            string scriptFile = Languages.GetStylesheetFile(language);
            AppendClientScript(textBuilder, scriptFile);
        }

        /// <summary>
        /// Appends the reference to the theme-specific style sheet.
        /// </summary>
        /// <param name="textBuilder"><see cref="StringBuilder"/> that creates the formatted text.</param>
        protected internal virtual void AppendThemeStylesheet(StringBuilder textBuilder)
        {
            string stylesheet = string.Format("shTheme{0}.css", Theme);
            AppendStyleSheet(textBuilder, stylesheet);
        }
        #endregion

        #region IFormatterProvider Members

        /// <summary>
        /// Called by the postbar engine in order to format text.
        /// </summary>
        /// <param name="raw">The unformatted text.</param>
        /// <param name="context">Contextual information for the transformation -
        /// like the user name, HTTP context, or purpose of the formatter run.</param>
        /// <returns>Formatted text.</returns>
        /// <remarks>
        /// <para>
        /// This formatter detects blocks of source code. The first word within a source code
        /// block is considered a hint on in which language the block is - if this first word
        /// is one of the supported languages.
        /// </para>
        /// <para>
        /// Postbar formats code blocks with a "pre" tag - this is done in phase 1 of the transformation;
        /// this is why we run in phase 2. THe Syntax Highlighter scripts also use the "pre" tag,
        /// augmented with a CSS class that defines the language ("brush", as it cals it).
        /// Now all we need to do is:<br/>
        /// * Look for "pre" tags
        /// * Get the first word behind it.
        /// * If this first word is a suported language, use it; otherwise ignore and use the
        /// default language.
        /// * Add the CSS class for the brush.
        /// to the "pre" tag.
        /// * Da capo al fine.
        /// * Inject links to the Syntax Highlighter CSS and script files. Each language
        /// has its own CSS file; in order to make things more efficient we only add files
        /// that are actually needed because the language was found in a script block.
        /// </para>
        /// </remarks>
        public virtual string Format(string raw, ContextInfo context)
        {
            // Only format the post content
            if (context.FormatContext.CompareTo(FormattingContext.PostContent) != 0)
                return raw;

            // Buckets for the remainders of unformatted text, and already formatted text.
            string sourceText = raw;
            StringBuilder targetText = new StringBuilder();

            // Find any part of the unformatted text that is enclosed in in a "pre" tags.
            // ScrewTurn formats code blocks into preformatted HTML tags.
            string openingTag = @"<pre>";
            string closingTag = @"</pre>";
            Regex regex = new Regex(openingTag + ".+?" + closingTag, RegexOptions.IgnoreCase | RegexOptions.Singleline);
            Match match = regex.Match(sourceText);
            while (match.Success)
            {
                // Push the text before the found code block into the target text
                // without alteration
                if (match.Index > 0)
                {
                    targetText.Append(sourceText.Substring(0, match.Index));
                }

                // Remove the part before the found code block, and the code block, from the remaining
                // source text
                sourceText = sourceText.Substring(match.Index + match.Length);

                // Get the content of the found code block
                string content = match.Value;

                // The RegEx match still contains the opening and closing tags. Remove them so we get only the
                // text within the tag.
                int openingTagLen = openingTag.Length;
                int closingTagLen = closingTag.Length;
                int contentLen = content.Length - closingTagLen - openingTagLen;
                content = content.Substring(openingTagLen, contentLen);

                // Get the first word of the code block. If it matched one of the highlighter
                // languages, use it as a hint on how to format the code block and remove it from the document.
                var wordSeparators = new char[] { ' ', '\n', '\r' };
                string firstWord = content
                  .Split(wordSeparators, StringSplitOptions.RemoveEmptyEntries)
                  .FirstOrDefault();

                // If a first word could be extracted (the block can as well be empty...),
                // and the language is supported, then...
                string language;
                if (!string.IsNullOrEmpty(firstWord) && Languages.IsSupported(firstWord))
                {
                    // ... set the language for this block...
                    language = firstWord;

                    // ... and remove the first word from the code block content.
                    int firstWordIndex = content.IndexOf(firstWord);
                    content = content.Substring(firstWordIndex + firstWord.Length);
                }
                else
                {
                    // If no langauge could be found, use the default language.
                    language = DefaultLanguage;
                }

                // Track the languages found on the page so we can include the correct set of script files.
                if (!foundLanguages.Contains(language))
                {
                    foundLanguages.Add(language);
                }

                // Add an opening "pre" tag with a language ("brush") definition...
                targetText.AppendFormat(
                  "<pre class='brush: {0}'>\n",
                  language.ToLowerInvariant());
                // ... the content...
                targetText.Append(content);
                // ... and a closing tag.
                targetText.Append("</pre>");

                // Get the next code block.
                match = regex.Match(sourceText);
            }

            // Append rest of source text to target.
            targetText.Append(sourceText);

            // Return the formatted text.
            return targetText.ToString();
        }

        /// <summary>
        /// Format the post title .
        /// the title is not modified by this plugin.
        /// </summary>
        /// <param name="title">The post title.</param>
        /// <param name="context">The context information.</param>
        /// <returns>The original title.</returns>
        public string FormatPostTitle(string title, ContextInfo context)
        {
            return title;
        }

        /// <summary>
        /// Format the page head, if any.
        /// </summary>
        /// <param name="head">The head content</param>
        /// <param name="context">The context information.</param>
        /// <returns>The formatted head</returns>
        public string FormatPageHead(string head, ContextInfo context)
        {
            return head;
        }

        /// <summary>
        /// Format the page foot, if any.
        /// Just return the js script registration in the head
        /// </summary>
        /// <param name="foot">The foot content</param>
        /// <param name="context">The context information.</param>
        /// <returns>The original foot</returns>
        public string FormatPageFoot(string foot, ContextInfo context)
        {
            StringBuilder targetText = new StringBuilder();
            targetText.AppendLine("\n\n");
            AppendStyleSheet(targetText, "shCore.css");
            AppendThemeStylesheet(targetText);
            AppendClientScript(targetText, "shCore.js");
            foreach (var language in foundLanguages)
            {
                AppendBrushScript(targetText, language);
            }
            // Add script that hooks up the Flash-based clipboard helper, and the activate the
            // syntax highlighter.
            targetText.Append("<script language='javascript'>\nSyntaxHighlighter.config.clipboardSwf = '");
            targetText.Append(ClientScriptBaseUrl);
            targetText.Append("scripts/clipboard.swf'\nSyntaxHighlighter.all();\n</script>");

            targetText.AppendLine("\n\n");
            foot += targetText.ToString();

            return foot;
        }

        /// <summary>
        /// Initializes the plugin. This is the very first method called on the
        /// class.
        /// </summary>
        /// <param name="host">Provides access to the wiki's API</param>
        /// <param name="config">Configuration string for the plugin.</param>
        public void Init(IHost host, string config)
        {
            this.host = host;
            ConfigurationString = config;
        }

        /// <summary>
        /// Shuts the plugin down. Very last method called on the clas.
        /// </summary>
        public void Shutdown()
        {
            // Nothing to do to shut the formatter down
        }

        /// <summary>
        /// Plugin information
        /// </summary>
        public virtual PluginInfo Information
        {
            get
            {
                return info;
            }
        }

        /// <summary>
        /// HTML text displayed as help for configuring the plugin
        /// </summary>
        public virtual string ConfigHelpHtml
        {
            get
            {
                return @"
<div>
  <b>选项:</b><br/>
  <ul>
    <li><b>ScriptUrl</b> 加载JS和CSS文件的路径，可以是网络地址。</li>
    <li><b>Theme</b> 语法高亮插件所使用的主题，不设置将使用默认主题。</li>
    <li><b>DefaultLang</b> 默认语言，即当不设置高亮语言时，所有默认输出的语言类型，如不设置此项，默认语言为 text</li>
    <li><b>CustomLang</b> 添加自定义语言，指定其对应的CSS文件</li>
  </ul>
  <b>例子:</b><br/>
  加载JS和CSS文件的路径为本地路径，使用 Django 主题，默认语言为 C#，添加自定义语言为 MyNewLang1 和 MyNewLang2 并指定其JS语法文件为 MyNewlang1.js 和 MyNewlang2.js，两者间使用分号:隔开，如要添加多个自定义语言，需使用|以分隔开, 配置如下：<br>
  ScriptUrl=~/Plugins/SyntaxHighlighter/;<br>
  Theme=Django;<br>
  DefaultLang=csharp;<br>
  CustomLang=MyNewLang1:MyNewlang1.js|MyNewLang2:MyNewlang2.js;
</div>
      ";
            }
        }

        /// <summary>
        /// 插件加载的优先级
        /// </summary>
        public int ExecutionPriority
        {
            get
            {
                return 20;
            }
        }

        #endregion
    }
}

OK，现在插件已做好了，为了测试插件是否成功，我们还需要创建一个测试项目，项目名为：PluginTest，然后添加以下单元测试类：

PluginsTester.cs 文件，填写以下测试函数：

[TestMethod]
public void SyntaxHighlighter_TestWithoutCore()
{
    IFormatterProvider syntax = new SyntaxHighlighter();
    string str = "<pre>Code</pre>";
    string cshart = "<pre>Csharp Code</pre>";
    string foot = "copyright";

    ContextInfo info = new ContextInfo(FormattingContext.PageFooter, HttpContext.Current, "Winson");
    foot = syntax.FormatPageFoot(foot, info);

    info = new ContextInfo(FormattingContext.PostContent, HttpContext.Current, "Winson");
    str = syntax.Format(str, info);

    info = new ContextInfo(FormattingContext.PostContent, HttpContext.Current, "Winson");
    cshart = syntax.Format(cshart, info);
    TestContext.WriteLine(str + cshart + foot);
    StringAssert.Contains(str, "<pre class='brush: text'>");
}

呵，本例经测试正常通过啦，最后提供全套源码给大家下载吧，感兴趣的朋友可慢慢研究下

下载Demo代码：CoderBlog.PluginFramework.rar

本文链接

.Net插件框架的实现及分析（二）

2011-09-27T10:03:00Z

.Net插件框架的实现及分析导航

.Net插件框架的实现及分析（一）
.Net插件框架的实现及分析（二）

.Net插件框架的实现及分析（三）

呵，很久之前发表了 .Net插件框架的实现及分析（一），只是一直没在此接上，只是在我自己的代码部落里更新了，现在也加上吧:

话接上回，让我们来继续分析下这个插件框架如何实现吧。既然是插件，就必须得动态加载，只需将编译好的插件DLL文件放到指定的插件目录下就可以使用了，这样就有一个动态获取插件的过程，我们此例中为文章内容格式化插件，当然就不只一个格式化插件在同一时间里使用了，所以需先创建的一个集合来收集这些插件：

ProviderCollector.cs 文件：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CoderBlog.Core
{
    /// <summary>
    /// 实现一个泛型插件 Provider 集合
    /// </summary>
    /// <typeparam name="T">集合类型.</typeparam>
    public class ProviderCollector<T>
    {
        private List<T> list;

        /// <summary>
        /// 初始化新的实体
        /// </summary>
        public ProviderCollector()
        {
            list = new List<T>(3);
        }

        /// <summary>
        /// 添加一个 Provider 到集合
        /// </summary>
        /// <param name="provider">需添加的 Provider.</param>
        public void AddProvider(T provider)
        {
            lock (this)
            {
                list.Add(provider);
            }
        }

        /// <summary>
        /// 从集合里移除一个 Provider
        /// </summary>
        /// <param name="provider">需移除的 Provider</param>
        public void RemoveProvider(T provider)
        {
            lock (this)
            {
                list.Remove(provider);
            }
        }

        /// <summary>
        /// 获取所有的 Providers (返回数组).
        /// </summary>
        public T[] AllProviders
        {
            get
            {
                lock (this)
                {
                    return list.ToArray();
                }
            }
        }

        /// <summary>
        /// 获取一个 Provider, 按类型名称搜索
        /// </summary>
        /// <param name="typeName">类型名称</param>
        /// <returns>所找到的 Provider</returns>
        public T GetProvider(string typeName)
        {
            lock (this)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    if (list[i].GetType().FullName.Equals(typeName)) return list[i];
                }
                return default(T);
            }
        }
    }

}

然后还要创建一个管理插件 Provider 集合实例的类：

Collectors.cs 文件

using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;
using CoderBlog.PluginFramework;

namespace CoderBlog.Core
{
    /// <summary>
    /// 包含了 Providers 集合的实例
    /// </summary>
    public static class Collectors
    {
        /// <summary>
        /// Contains the file names of the DLLs containing each provider (provider->file).
        /// </summary>
        public static Dictionary<string, string> FileNames;

        /// <summary>
        /// 使用中的格式化插件的 Provider 集合
        /// </summary>
        public static ProviderCollector<IFormatterProvider> FormatterProviderCollector;

        /// <summary>
        /// 禁用中的格式化插件的 Provider 集合
        /// </summary>
        public static ProviderCollector<IFormatterProvider> DisabledFormatterProviderCollector;

        /// <summary>
        /// 查找一个 provider.
        /// </summary>
        /// <param name="typeName">Provider 类型名称</param>
        /// <param name="enabled">指定此 Provider 是否开启</param>
        public static IProvider FindProvider(string typeName, out bool enabled)
        {
            enabled = true;
            IProvider prov = null;

            prov = FormatterProviderCollector.GetProvider(typeName);
            if (prov == null)
            {
                prov = DisabledFormatterProviderCollector.GetProvider(typeName);
                if (prov != null) enabled = false;
            }
            if (prov != null) return prov;

            return null;
        }

        /// <summary>
        /// 尝试卸载一个 provider.
        /// </summary>
        /// <param name="typeName">provider 名称</param>
        public static void TryUnload(string typeName)
        {
            bool enabled;
            IProvider prov = FindProvider(typeName, out enabled);

            FormatterProviderCollector.RemoveProvider(prov as IFormatterProvider);
            DisabledFormatterProviderCollector.RemoveProvider(prov as IFormatterProvider);
        }

        /// <summary>
        /// 尝试禁用一个 provider.
        /// </summary>
        /// <param name="typeName">provider 名称</param>
        public static void TryDisable(string typeName)
        {
            IProvider prov = null;

            prov = FormatterProviderCollector.GetProvider(typeName);
            if (prov != null)
            {
                DisabledFormatterProviderCollector.AddProvider((IFormatterProvider)prov);
                FormatterProviderCollector.RemoveProvider((IFormatterProvider)prov);
                return;
            }
        }

        /// <summary>
        /// 尝试开启一个 provider.
        /// </summary>
        /// <param name="typeName">provider 名称</param>
        public static void TryEnable(string typeName)
        {
            IProvider prov = null;

            prov = DisabledFormatterProviderCollector.GetProvider(typeName);
            if (prov != null)
            {
                FormatterProviderCollector.AddProvider((IFormatterProvider)prov);
                DisabledFormatterProviderCollector.RemoveProvider((IFormatterProvider)prov);
                return;
            }
        }

        /// <summary>
        /// 获取所有 providers, 包含启用和禁用的
        /// </summary>
        /// <returns>providers 的名称.</returns>
        public static string[] GetAllProviders()
        {
            List<string> result = new List<string>(20);

            foreach (IProvider prov in FormatterProviderCollector.AllProviders) result.Add(prov.GetType().FullName);
            foreach (IProvider prov in DisabledFormatterProviderCollector.AllProviders) result.Add(prov.GetType().FullName);

            return result.ToArray();
        }
    }
}

接下来就可以开始正式编写加载插件 Provider 的代码了，创建一个 ProviderLoader 类：

ProviderLoader.cs 文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using CoderBlog.PluginFramework;
using System.Reflection;

namespace CoderBlog.Core
{
    /// <summary>
    /// 加载插件的 Provider
    /// </summary>
    public static class ProviderLoader
    {
        /// <summary>
        /// 列出所有插件的程序集
        /// </summary>
        /// <returns></returns>
        public static string[] ListPluginAssemblies()
        {
            string pluginPath = System.Web.HttpRuntime.AppDomainAppPath + "plugins";
            string[] files = Directory.GetFiles(pluginPath, "*.dll");
            string[] result = new string[files.Length];
            for (int i = 0; i < files.Length; i++) result[i] = Path.GetFileName(files[i]);
            return result;

        }

        /// <summary>
        /// 加载插件
        /// </summary>
        public static void Load()
        {
            string[] pluginAssemblies = ListPluginAssemblies();

            //分别创建2个对象以存放开始和禁用的插件
            List<IFormatterProvider> forms = new List<IFormatterProvider>();
            List<IFormatterProvider> dForms = new List<IFormatterProvider>();

            for (int i = 0; i < pluginAssemblies.Length; i++)
            {
                IFormatterProvider[] f;
                LoadFrom(pluginAssemblies[i], out f);
                forms.AddRange(f);

            }

            for (int i = 0; i < forms.Count; i++)
            {
                //加载并初始化插件
                Initialize<IFormatterProvider>(forms[i],
                    Collectors.FormatterProviderCollector,
                    Collectors.DisabledFormatterProviderCollector);
            }
        }

        /// <summary>
        /// 初始化插件 Provider
        /// </summary>
        /// <typeparam name="T">当前插件接口类型</typeparam>
        /// <param name="instance">插件实体</param>
        /// <param name="collectorEnabled">开启中的插件集合</param>
        /// <param name="collectorDisabled">禁用中的插件集合</param>
        private static void Initialize<T>(T instance, ProviderCollector<T> collectorEnabled,
            ProviderCollector<T> collectorDisabled) where T : class, IProvider
        {
            if (collectorEnabled.GetProvider(instance.GetType().FullName) != null ||
                collectorDisabled.GetProvider(instance.GetType().FullName) != null)
            {
                //如果为空，则直接返回
                return;
            }

            bool enabled = !IsDisabled(instance.GetType().FullName);
            try
            {
                if (enabled)
                {
                    //只对启用的插件进行初始化操作，并设置插件所需的配置文件，
                    //此方法最终由具体的插件类去实现
                    //以下只为演示说明，所以直接指定了配置文件路径和名称了，
                    //正常情况下应该再写一个 Provider 去动态获取配置文件具体路径的
                    instance.Init(Host.Instance, "~/plugins/config.ini");
                }
            }
            catch
            {
                // 禁用插件 Provider
                enabled = false;
                //保存插件状态，本例为将状态保存到文本文件中
                //具体实现在此也不写出来了，否则就要连带着另一个配置类 provider，太多了，呵
                //SaveStatus(instance.GetType().FullName, false);
                throw; // 再次抛出异常，因为不是正常执行中
            }
            if (enabled) collectorEnabled.AddProvider(instance);
            else collectorDisabled.AddProvider(instance);

        }

        /// <summary>
        /// 动态加载自程序集的插件
        /// </summary>
        /// <param name="assembly">程序集名称</param>
        /// <param name="formatters">格式化插件数组，可同时加载多个</param>
        public static void LoadFrom(string assembly, out IFormatterProvider[] formatters)
        {
            Assembly asm = null;
            try
            {
                //asm = Assembly.LoadFile(assembly);
                // 使用此方法可让DLL不会被锁住，加载完后还可以被删除
                asm = Assembly.Load(LoadAssemblyFromProvider(Path.GetFileName(assembly)));
            }
            catch
            {
                formatters = new IFormatterProvider[0];
                return;
            }

            Type[] types = null;

            try
            {
                types = asm.GetTypes();
            }
            catch (ReflectionTypeLoadException)
            {
                formatters = new IFormatterProvider[0];
                return;
            }

            List<IFormatterProvider> frs = new List<IFormatterProvider>();

            Type[] interfaces;
            for (int i = 0; i < types.Length; i++)
            {
                // 避免加载到抽象类，它们不能被实例化
                if (types[i].IsAbstract) continue;

                interfaces = types[i].GetInterfaces();
                foreach (Type iface in interfaces)
                {
                    //这里也可以添加其他插件的 proivder，加多几个 if 判断即可
                    if (iface == typeof(IFormatterProvider))
                    {
                        IFormatterProvider tmpf = CreateInstance<IFormatterProvider>(asm, types[i]);
                        if (tmpf != null)
                        {
                            frs.Add(tmpf);
                            Collectors.FileNames[tmpf.GetType().FullName] = assembly;
                        }
                    }
                }
            }
            formatters = frs.ToArray();
        }

        /// <summary>
        /// 创建一个提供者的实例
        /// </summary>
        /// <typeparam name="T">提供者接口类型</typeparam>
        /// <param name="asm">包含指定类型的程序集</param>
        /// <param name="type">要创建的实例类型</param>
        /// <returns>创建的实例，或者 <c>null</c>.</returns>
        private static T CreateInstance<T>(Assembly asm, Type type) where T : class, IProvider
        {
            T instance;
            try
            {
                instance = asm.CreateInstance(type.ToString()) as T;
                return instance;
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// 检测插件是否被禁用
        /// </summary>
        /// <param name="typeName">类型名称</param>
        /// <returns></returns>
        public static bool IsDisabled(string typeName)
        {
            //具体逻辑请自行实现啦，可从配置类里获取插件状态
            return true;
        }

        /// <summary>
        /// 从程序集加载提供者
        /// </summary>
        /// <param name="assemblyName">程序集文件名</param>
        /// <returns></returns>
        private static byte[] LoadAssemblyFromProvider(string filename)
        {
            if (filename == null) throw new ArgumentNullException("filename");
            if (filename.Length == 0) throw new ArgumentException("filename");

            if (!File.Exists(GetPluginFullPath(filename))) return null;

            //此函数代码其实应该放到配置类实现，然后使用lock以保证线程安全，
            //在此只为了演示，所以先放到此片了
            //lock (this)
            //{
                try
                {
                    return File.ReadAllBytes(GetPluginFullPath(filename));
                }
                catch (IOException)
                {
                    return null;
                }
            //}
        }

        /// <summary>
        /// 根据文件名获取完整的插件路径
        /// </summary>
        /// <param name="filename"></param>
        /// <returns></returns>
        private static string GetPluginFullPath(string filename)
        {
            //具体请自行实现，同理，此函数也应该放到配置类
            return "";
        }
    }

}

OK，到此整个插件框架已基本完成了。下一篇将说说如何使用此框架来创建一个简单的插件

本文链接

.Net插件框架的实现及分析（一）

2010-09-19T03:15:00Z

.Net插件框架的实现及分析导航

.Net插件框架的实现及分析（一）
.Net插件框架的实现及分析（二）

.Net插件框架的实现及分析（三）

在开始自己系统的同时，总想将系统做得更灵活，可让其他人非常方便地参与进来，这就需要一个完善的插件系统，今天我准备写一个插件框架系列的文章，主要是想记录下我学习 ScrewTurn Wiki 系统的成果，也方便需要的人查阅

我个人感觉 ScrewTurn Wiki 系统的插件框架做得相当好，可让后期制作插件的人方便地将系统进行整合，所以这段时间都在研究。现大概说一下一个插件框架的架构和需求吧。我认为一个插件系统，应该可以独立于现有系统的类库，让第三方开发者只引用一个插件项目的DLL即可完成所有相关的开发，而且对系统框架要有一定的、统一的约定，不能让第三方开发者想怎样设计就怎样设计，因此一般的插件框架都是接口来实现会比较好，以下将说说大致的调用流程，呵，我就不画流程图啦（主要是我也懒得安装），只用文字说明一下吧：

用户访问网站 --> 调用核心功能函数 --> 调用实现此核心功能的接口

因此通过实现不同的接口，就可以方便地实现不同的功能函数，也达到了实现不同插件的效果，这个道理很简单，只要有接触过OO的人都会知道，但具体要如何实现呢，以下将慢慢道来。此插件框架主要使用了接口+Provider模式实现，因此需先设计好要被实现的接口，以下仅以一个格式化的功能为例吧，此格式化功能插件主要是在文章发布后对内容进行格式化处理，如可为此创建代码高亮插件、查看次数插件等，都是在文章输出时调用不同的格式化插件进行处理即可。 OK，第一步我们先定义好一个全局总的 IProvider 接口，好让之后所有插件都基于这些接口进行：

IProvider.cs 文件：

namespace CoderBlog.PluginFramework
{
    public interface IProvider
    {
        /// <summary>
        /// 初始化插件
        /// </summary>
        /// <param name="host">主系统对象，可让插件调用主系统里的方法，以达到解耦合</param>
        /// <param name="config">插件配置文件</param>
        void Init(IHost host, string config);

        /// <summary>
        /// 当注销插件时调用
        /// </summary>
        void Shutdown();

        /// <summary>
        /// 插件开发者相关信息
        /// </summary>
        PluginInfo Information { get; }

        /// <summary>
        /// 插件帮助信息
        /// </summary>
        string ConfigHelpHtml { get; }
    }
}

由于这个是最基础的接口类，所以包含的方法都是最能用的，每个类型的插件都应该会用到。这里顺便提一下 IHost 这个接口，这个是主系统函数调用的接口，可以放置一些插件系统里需要用到的一些常用方法和获取系统配置系统的函数等，以下我只提供2个接口以当演示，具体大家可根据自己需要去设计，因此接口并不是本系统的重点，代码如下：

IHost.cs 文件：

namespace CoderBlog.PluginFramework
{
    /// <summary>
    /// 这里只需提供常用的功能函数和配置信息即可
    /// </summary>
    public interface IHost
    {
        /// <summary>
        /// 获取用户列表
        /// </summary>
        /// <returns></returns>
        List<UserInfo> GetUsers();

       /// <summary>
       /// 获取插件提供者配置文件
       /// </summary>
       /// <param name="providerTypeName">插件类型名称</param>
       /// <returns></returns>
        string GetProviderConfiguration(string providerTypeName);
    }
}

接下来我们开始设计针对文本格式化的插件接口，此接口将继承上面的基类接口（后继开始所有类型的插件都应该继承自 IProvider）。

由于要对当前输出内容进行格式化，所以还需让插件开发者知道当前的上下文环境，以方便调用所需的信息，同时如果想再灵活些的话，可添加一个格式化对象的枚举，指明当前插件只格式化哪部分信息，因此需先创建一个 FormattingContext 枚举和 ContextInfo 类以传递所需的信息，可在一个 ContextInfo.cs 文件里包含以上2个类：

ContextInfo.cs 文件：

namespace CoderBlog.PluginFramework
{
    public class ContextInfo
    {
        /// <summary>
        /// 包含了所需的页面上下文信息
        /// </summary>
        public class ContextInfo
        {
            private FormattingContext context;
            private HttpContext httpContext;
            private string username;

            /// <summary>
            /// 初始化格式化对象所需的上下文对象
            /// </summary>
            /// <param name="context">格式化枚举对象</param>
            /// <param name="httpContext">当前 http 上下文</param>
            /// <param name="username">当前用户名</param>
            public ContextInfo(FormattingContext context,
                               HttpContext httpContext, string username)
            {
                this.context = context;

                this.httpContext = httpContext;
                this.username = username;
            }

            /// <summary>
            /// 获取当前格式化枚举对象
            /// </summary>
            public FormattingContext FormatContext
            {
                get { return context; }
            }

            /// <summary>
            /// 获取当前 http 上下文
            /// </summary>
            public HttpContext HttpContext
            {
                get { return httpContext; }
            }

            /// <summary>
            /// 获取当前用户名
            /// </summary>
            public string Username
            {
                get { return username; }
            }
        }

        /// <summary>
        /// 格式化枚举，指定需要格式化哪部分的信息
        /// </summary>
        public enum FormattingContext
        {
            /// <summary>
            /// 侧栏
            /// </summary>
            Sidebar,
            /// <summary>
            /// 帖子标题
            /// </summary>
            PostTitle,
            /// <summary>
            /// 帖子内容
            /// </summary>
            PostContent,
            /// <summary>
            /// 页面头部
            /// </summary>
            PageHeader,
            /// <summary>
            /// 页面底部
            /// </summary>
            PageFooter,
            /// <summary>
            /// 未知
            /// </summary>
            Unknown
        }
    }
}

OK，现在我们可以创建 IFormatterProvider 接口了：

IFormatterProvider.cs 文件：

namespace CoderBlog.PluginFramework
{
    public interface IFormatterProvider : IProvider
    {
        /// <summary>
        /// 对指定内容进行格式化
        /// </summary>
        /// <param name="content">需格式化的内容</param>
        /// <param name="context">当前格式化对象上下文</param>
        /// <returns>格式化后的内容</returns>
        string Format(string content, ContextInfo context);

        /// <summary>
        /// 格式化帖子标题
        /// </summary>
        /// <param name="title">需格式化的帖子标题</param>
        /// <param name="context">当前格式化对象上下文</param>
        /// <returns>格式化后的内容</returns>
        string FormatPostTitle(string title, ContextInfo context);

        /// <summary>
        /// 格式化页面头部内容
        /// </summary>
        /// <param name="head">需格式化的页面头部内容</param>
        /// <param name="context">当前格式化对象上下文</param>
        /// <returns>格式化后的内容</returns>
        string FormatPageHead(string head, ContextInfo context);

        /// <summary>
        /// 格式化页面底部
        /// </summary>
        /// <param name="foot">需格式化的页面底部内容</param>
        /// <param name="context">当前格式化对象上下文</param>
        /// <returns>格式化后的内容</returns>
        string FormatPageFoot(string foot, ContextInfo context);

       /// <summary>
       /// 格式化插件的执行优先级，此处很重要，因如多个格式化插件同时执行时，
       /// 可能会覆盖其他的格式，所以要有个优先级问题
       /// </summary>
        int ExecutionPriority { get; }
    }
}

此接口设计好后，以后所有与格式化相关的插件，都必须实现此接口，然后可根据插件作者需要实现不同的接口方法去格式化相应的内容。

OK，这篇就先讲到这吧，所需要的接口都定义好了，下一篇将详解如何实现相关的接口

本文链接

在类库中调用资源文件实现国际化！

2010-09-07T23:33:00Z

这段时间以来，我都被这个问题困扰着，如何能在类库中直接调用资源文件以达到国际化效果呢？

因为资源文件只存在于UI层面，所以底层类库不能直接调用，曾考虑过在底层直接返回信息代码，然后在UI层显示，但当遇到需要直接在底层写日志的时候，这种方式就不行了。

然后又想到了干脆将所有资源文件都做成一个独立的类库，这样不管在哪里都可以直接调用了，但另一个问题又来了，就是如果这样做后，那就会造成每修改一次资源文件，就要重新编译整个项目，即当程序发布后，用户就不能方便地对资源文件进行修改了，所以这样做也不方便。

那有没有更好的方法呢？呵，最近在研究 ScrewTurn Wiki 系统，发现有非常多值得学习的地方，其中就有在类库中调用资源文件的方法，其实原理也很简单，就是使用接口，达到后期绑定的效果，UI实现了获取资源的接口后，在类库里再调用此接口，就可以达到所要的效果了。

当然，并没有两全其美的办法，使用此方法的一个弊端就是，在调用接口获取资源文件时，不能使用智能提示的方式直接点出相关的KEY，只能手工输入一个字符串的KEY，再根据KEY以获取具体的语言信息，其实就是使用了 ResourceManager 的 GetString 方法实现的，以下是具体的代码：

1、先创建 IResource 接口：

/// <summary>
/// 在类库层面获取资源
/// </summary>
public static class Resource
{
    private static IResource coreMessage;

    /// <summary>
    /// 获取或设置资源对象
    /// </summary>
    public static IResource CoreMessage
    {
        get { return coreMessage; }
        set { coreMessage = value; }
    }
}

4、最后在需要的地方直接调用即可，如在类库写日志时调用：

Log.LogEntry(Resource.CoreMessage.GetResource("Provider_AlreadyInMemory"), EntryType.Warning, Log.SystemUsername);

上面也说过，此方法的缺点就是在调用时要手工输入相应的KEY的字符串，这也有可能会导致万一输入错了KEY，就会报错了，所以在获取时最好加上异常处理，以防止运行时的错误，至于这个问题，我个人觉得比起不能调用要好些啦，呵呵

本文链接

Javascript下调用.Net资源文件，实现语言国际化

2010-07-17T07:43:00Z

大家都知道，要在.Net下实现国际化是很简单的事，只需添加一个 App_GlobalResources 目录和相应的资源文件（.resx），然后就可以直接调用了，如现有一资源文件名为： Admin.resx，其中有一个叫 Title 的键值，这时在页面只需直接使用

string title = Resources.Admin.Title;

但如果想在JS里也使用此资源文件，要如何处理呢？其实也很简单，只需使用AJAX调用后台获取资源文件即可，以下就使用jQuery + ASP.NET MVC为例实现在JS下直接调用资源文件的方法（当然你也可以直接使用传统的JS AJAX方法获取）

先创建获取资源文件的函数：

public ActionResult GetResource(FormCollection collection)
{
            //此为自定义信息返回类，方便返回相应的ajax结果
            Message msg = new Message();

            //调用 ResourceManager 以获取相应的资源文件
            ResourceManager rm = (ResourceManager)System.Type.GetType
                ("Resources." + collection["category"]).GetProperty("ResourceManager",
                BindingFlags.Static | BindingFlags.NonPublic).GetValue(null, null);
            msg.Content = rm.GetString(collection["key"]) ?? "";

            //由于我用的是ASP.NET MVC，所以直接使用 Json(obj) 返回即可
            return Json(msg);
}

Ok，万事具备啦，现在可以直接调用了，在JS里如要显示以上 Title 的语言，就可以使用以下代码调用：

alert(Resource("Admin", "Title"));
//or
var title = Resource("Admin", "Title");

这样就可以在JS里轻松实现语言国际化效果了!

本文链接

让 PowerDesigner 支持 SQLite!

2010-06-22T01:05:00Z

PowerDesigner是一个功能强大的数据库设计软件，最近正在用其设计新系统的数据库，但由于在项目初级阶段，希望使用轻量级的 SQLite 来做测试会比较方便，不过发现 PowerDesigner 里好像没有直接支持 SQLite 的 DBMS，这样所创建的数据表就不能直接在 SQLite 里生成了，感觉不太爽

不过事情总有解决的办法，其实只需要安装上 SQLite 的驱动，就可以让 PowerDesigner 支持直接生成到 SQLite 里了，SQLite 的驱动下载：

http://www.ch-werner.de/sqliteodbc/

但有朋友说即使安装了以上驱动也不行，因为在创建物理数据模型时也没有 SQLite 的选项，其实 SQLite 是属于 ODBC 的连接，说到这里，大家应该想到了吧，呵，没错，在选择 DBMS 时只要选择 ODBC 3.0 驱动就可以啦，这个就能生成 SQLite 相应的数据模型了，以下是操作方法：

1、创建新的物理数据模型，选择 ODBC 3.0：

2、创建完数据结构后，开始生成数据库，点击菜单的 Generate Database:

3、生成数据库时再选择 SQLite3.0 的驱动，然后再点确定就可以了：

最后再推荐大家一款非常好用的 SQLite 的可视化管理工具，可到以下地址下载： http://sqliteadmin.orbmu2k.de/

本文链接

理解依赖注入及其好处！

2010-02-09T01:04:00Z

关于依赖注入我看园子里已早有人发过相关的文章了，只是主要都是从理论角度出发，是一些虚拟的例子，感觉要真正运用起来的话可能有些朋友还不太清楚，最近我在公司的项目中就遇到一个比较麻烦的问题，正好可以使用依赖注入来解决，所以顺便写下我的心得，也方便自己以后查阅：最近在公司的项目中，遇到的问题是：我们需要使用一个第三方写的一个的控件（open source的）来生成组织架构的Chart图，其中在char...

图文说明如何使用T4在VS2008里生成代码

2010-01-20T14:25:00Z

谈起代码生成，相信大家对CodeSmith一定不会陌生，但可惜的是CodeSmith并不是一个免费的午餐，可是要收费的哦，因此如果对一些公司上的正式应用起来就可能不太方便了。其实微软早已为我们设计了套非常好用的代码生成模板，只要你装上了VS2008后就可以直接使用了，这套代码生成模板就叫 T4 ，全称为：Text Template Transformation Toolkit，其语法就和C#一样，...

Winson.Framework 3.3 发布！！

2009-09-27T15:37:00Z

Winson.Framework 3.3新版发布啦！！！感兴趣的朋友快来看看吧！同时也祝我们的祖国生日快乐！！另外要说明一下的是，之前我们的技术QQ群由于并非官方直接开的群，因此现已被解散了，如果对我们这个框架感兴趣或者有问题需要一起讨论的，欢迎加入我们的新QQ群：22203702 最后说说这次版本的更新项:一、功能更新： * 增加 order 语句的使用* 对所有数据类型均能输入空值，之前...

Silverlight学习问题总结(一)

2009-08-05T14:39:00Z

最近因为工作需要，也开始要学习Silverlight啦，呵呵。其实以前也想过要学这东西的，只是一直没空，而且更主要的是就算学到了，也无用武之地啊，因此如果工作中用到而去学的，那又是不同的感觉啦，起码很多东西可以马上学以至用了 :)这篇日志只是我在学习过程中遇到问题的解决，所以可能每个问题都比较简短或者零乱，因此也会不断更新。1、首先遇到的第一个问题，就是编译器的问题（真是出师不利）以前我也玩儿过...