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

 

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

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

.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<!-- START GreenIcicle code syntax highlighter, modified by Winson for PostBar -->\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<!-- END GreenIcicle code syntax highlighter, modified by Winson for PostBar -->\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