由浅入深：自己动手开发模板引擎——置换型模板引擎（二）

受到群里兄弟们的竭力邀请，老陈终于决定来分享一下.NET下的模板引擎开发技术。本系列文章将会带您由浅入深的全面认识模板引擎的概念、设计、分析和实战应用，一步一步的带您开发出完全属于自己的模板引擎。关于模板引擎的概念，我去年在百度百科上录入了自己的解释（请参考：模板引擎）。老陈曾经自己开发了一套网鸟Asp.Net模板引擎，虽然我自己并不乐意去推广它，但这已经无法阻挡群友的喜爱了！

上次我们简单的认识了一下置换型模板引擎的几种情况，当然我总结的可能不够完善，希望大家继续补充。谈到按流替代式模板引擎的原理但并没有给出真正的实现。跟帖的评论中有一位朋友（Treenew Lyn）说的很好：“Token 解析其实是按一个字符一个字符去解析的”。的确是这样，而且唯有这样才能够实现更加高效、更加准确的模板引擎机制。我们首先将模板代码分解成一个一个的Token，然后按照顺序形成Token流（顺序集合），在输出的时候替换规定好的语法标记即可。

目的

假定我们要处理的模板文件类似于如下格式（与上一节一样）：

/// <summary>
/// 模板文本。
/// </summary>
public const string TEMPLATE_STRING = @"<a href=""{url}"">{title}</a><br />";

我们的目的是将它按照{xxx}这样的标记分解成Token流。

方案

解决这个问题的方案大致有这么几种：

1. 最直观的就是正则表达式；
2. 比较拐弯但比正则快的就是split+各种技巧；
3. 按（字符）流解析 ，即将字符流转化为Token流；

今天我们只讨论第三种情况，第一种很简单，第二种稍微复杂一点，但相信难不倒您！第三种做法只是不太常见，但如果您接触过编译原理（或搜索引擎开发），就不是那么陌生了。

思路

首先，我们看看这段模板代码按字符流输出回是怎样的：

// 实现代码
[Test]
public void Test1()
{
    var s = new StringBuilder();

    foreach (var c in TestObjects.TEMPLATE_STRING)
    {
        // 这里我们用回车换行符将输出隔开
        s.AppendLine(c.ToString(CultureInfo.InvariantCulture));
    }

    Trace.WriteLine(s.ToString());
}

/* 输出结果如下
<
a
 
h
r
e
f
=
"
{
u
r
l
}
"
>
{
t
i
t
l
e
}
<
/
a
>
<
b
r
 
/
>
*/

这个结果显然与我们期望的相差很远（请留意飘红的字符们），其实我们需要的结果是这样的：

<a href=" 
{url}
">
{title}
</a><br />

基本上我们可以总结出如下规律（为了容易理解，我们这里只考虑{xxx}标记）：

1. 从开始到"{"之前的部分算作一个Token；
2. "{"、"}"之间的部分（含"{"、"}"）算作一个Token；
3. "}"、"{"之间的部分（不含"}"、"{"）算作一个Token；
4. "}"到结尾的部分算作一个Token；

思路有了，那么算法如何实现呢？为了避免篇幅过长，我这里直接给出一个有限状态机的解决方案。为了更加直观的理解这个问题，请您现在将鼠标定位在字符串"<a href=""{url}"">{title}</a><br />"的开始处，然后使用方向键向右移动光标，观察光标在每个位置（pos）的状态，图解如下：

这里出现了4个状态，分别是“开始”、“进入目标”、“脱离目标”和“结束”。而在实际编码过程中，我们通常忽略开始和结束，因为这两个状态始终都是需要处理的，而且各有且仅有1次，直接硬编码实现即可。

题外话：如果您实在难以理解什么是“有限状态机”的话，那么你可以简单的理解为“状态有限的机器（制）”，虽然这么说是非常不准确的，但这个可以帮助你去思考这个概念。另外可以参考“状态机”。

将字符流转化为Token流的过程

要利用有限状态机，我们首先要定义一下业务状态：

/// <summary>
/// 定义解析模式（即状态）。
/// </summary>
public enum ParserMode
{
    /// <summary>
/// 无状态。
/// </summary>
    None = 0,

    /// <summary>
/// 进入标签处理。
/// </summary>
    EnterLabel = 1,

    /// <summary>
/// 退出标签处理。
/// </summary>
    LeaveLabel = 2
}

在这里我们定义了三个状态，实际上只需要两个。None这个状态在实践中没有实际意义，只是为了在编码过程中让语义更加接近现实（面向对象编程中会有很多这种情况）。遇到"{"或"}"的时候就进行状态变换，而每次状态变换都需要做一些处理动作，下面是算法的主体骨架：

// 这俩还需要解释？？
private const char _LABEL_OPEN_CHAR = '{';
private const char _LABEL_CLOSE_CHAR = '}';

[Test]
public void Test2()
{
    var templateLength = TestObjects.TEMPLATE_STRING.Length;

    // 为了模拟光标的定位移动，我们在这里采用for而不是foreach
// 在本例中用for还是foreach都无关紧要
// 以后我们还会讨论更加复杂的情况，到时候就需要用到while(bool)了！
    for (var index = 0; index < templateLength; index++)
    {
        var c = TestObjects.TEMPLATE_STRING[index];

        switch (c)
        {
            case _LABEL_OPEN_CHAR:
                // ...
                this._EnterMode(ParserMode.EnterLabel);
                break;

            case _LABEL_CLOSE_CHAR:
                // ...
                this._LeaveMode();
                break;

            default:
                // ...
                break;
        }
    }

    // 到达结尾的时候也需要处理寄存器中的内容
// 这就是之前提到的硬编码解决开始和结束两个状态
// ...
}

在状态变换之前，我们需要一系列的寄存器（临时变量）来存储当前状态、历史状态（限于本例就是上次状态）、历史数据以及处理成功的Token等，定义如下：

/// <summary>
/// 表示 Token 顺序集合（Token流）。
/// </summary>
private readonly List<string> _tokens = new List<string>();

// 为有限状态机定义一个寄存器
// 注意：有限状态机的理解在物理层的电路上和在编程概念上是相通的
private readonly StringBuilder _temp = new StringBuilder();

/// <summary>
/// 表示当前状态。
/// </summary>
private ParserMode _currentMode;

/// <summary>
/// 表示上一状态。
/// </summary>
/// <remarks>
/// 如果状态多余两个的话，我们总不能再定义一个"_last_last_Mode"吧！
/// 在状态有多个的时候，需要使用 <see cref="Stack{T}"/> 来保存历史
/// 状态，这个我们将在解释型模版引擎中用到。
/// </remarks>
private ParserMode _lastMode;

切换模式的时候需要对各个寄存器做相应的处理，我的注释很详细就不解释了：

/// <summary>
/// 进入模式。
/// </summary>
/// <param name="mode"><see cref="ParserMode"/> 枚举值之一。</param>
private void _EnterMode(ParserMode mode)
{
    // 当状态改变的时候应当保存之前已处理的寄存器中的内容
    if (this._temp.Length > 0)
    {
        this._tokens.Add(this._temp.ToString());

        this._temp.Clear();
    }

    this._lastMode = this._currentMode;
    this._currentMode = mode;
}

/// <summary>
/// 离开模式。
/// </summary>
private void _LeaveMode()
{
    // 当状态改变的时候应当保存之前已处理的寄存器中的内容
// 当状态超过2个的时候，实际上这里的代码应该是不一样的
// 虽然现在我们只需要考虑两种状态，但为了更加直观的演示，我特意在这里又写了一遍
    if (this._temp.Length > 0)
    {
        this._tokens.Add(this._temp.ToString());
        this._temp.Clear();
    }

    // 因为只有两个状态，因此
    this._currentMode = this._lastMode;
}

然后再完善一下之前提到的主体骨架，测试，输出结果如下：

<a href="
{url}
">
{title}
</a><br />

我们得到了预期的结果！

将Token流输出为业务数据

在上一节中我们曾经提到过Token流输出时将标签置换为业务数据的思路，如果您忘记了，那么请回去再看看吧！

有了思路，那么实现就非常容易了，联合业务数据进行测试：

[Test]
public void Test3()
{
    this.ParseTemplate(TestObjects.TEMPLATE_STRING);

    foreach (var newsItem in TestObjects.NewsItems)
    {
        foreach (var token in this._tokens)
        {
            switch (token)
            {
                case "{url}":
                    Trace.Write(newsItem.Key);
                    break;

                case "{title}":
                    Trace.Write(newsItem.Value);
                    break;

                default:
                    Trace.Write(token);
                    break;
            }
        }

        Trace.WriteLine(String.Empty);
    }
}

经过测试输出结果完全正确！

搞定！ 

总结及代码下载

本文主要内容是阐述如何使用有限状态机这种机制来完成“从字符流向Token流”的转换的。不过本文为了降低入门门槛，一切举例和算法都从简，大家应该很容易上手！

要补充的是，本文并没有真正的去封装一个模板引擎，而仅仅是说明了其工作原理，我想这个比直接给大家一个已经实现的模板引擎要好的多，毕竟这是“渔”而不是“鱼”。

本文代码下载：置换型模板引擎(1-2).zip

---

下集预报：置换型模板引擎（三）将于清明节之后放出，届时将会封装一个简单但完整的基于“按流替代式”的模板引擎，达到实用级别。

另外，请大家不要催促我博文的写作，老陈毕竟不是打印机啊！哈哈！