一个简单的变量替换型模版

这个是为了Micolog.Net的“主题预编译”制作的模版工具。主要负责简单的模版替换，以及在模版文件中调用C#方法。

Micolog.Net 的主题机制采用的是XML的数据+XSLT转码生成HTML。在一个博客系统中，有很多设置，比如博客名称等是不经常更换的，与其在每次生成html时都从XML中转换，不如直接在选择主题时直接对这些设置进行替换。考虑到主题应有的扩展性，这个模版机制采用“注入方法”的方式实现。

首先看一个最简单的例子：

            var template = new Micolog.Common.Template.Simple();
            template.LoadString("Hi,I'm {$Username}");
            template.Parameters.Add("Username", "Soar、毅");
            template.Process();
            Console.WriteLine(template.ToString());
            //将输出 Hi,I'm Soar、毅

其次，有时候，我们会需要对传入的参数格式化，比如输出按照一定格式的日期：

            var template = new Micolog.Common.Template.Simple();
            template.LoadString("Hi,I'm {$Username} And Now Is {$Now:yyyy年MM月dd日}");
            template.Parameters.Add("Username", "Soar、毅");
            template.Parameters.Add("Now", DateTime.Now);
            template.Process();
            Console.WriteLine(template.ToString());
            //将输出 Hi,I'm Soar、毅 And Now Is 2012年08月24日

在做到这一步的时候，这个简单的模版引擎算是差不多了。可是还缺少点什么：扩展。因为一个博客模版在安装完成后，可能需要进行一些自定义的设置。这些设置就要通过另一个方法来完成了。这个就是，动态的调用方法，通过传入不同的参数实现扩展，并且可以定义默认值：

            var template = new Micolog.Common.Template.Simple();
            template.LoadString("Hi,I'm {$Username} And Now Is {$Now:yyyy年MM月dd日}\n1 + 1 = {$Add(1,1)}\n{$NotDifine(1,1),默认值}");
            template.Parameters.Add("Username", "Soar、毅");
            template.Parameters.Add("Now", DateTime.Now);
            template.Methods.Add("Add", (arg) => 
            {
                if (arg == null || arg.Length != 2) return "参数不正确!";
                return (Convert.ToInt32(arg[0]) + Convert.ToInt32(arg[1])).ToString();
            });
            template.Process();
            Console.WriteLine(template.ToString());
            //将输出
            //Hi,I'm Soar、毅 And Now Is 2012年08月24日
            //1 + 1 = 2
            //默认值

简单的引擎就是简单的引擎，不带有IF判断，For循环等。但是功能够用了。至少在Micolog.Net中够用了。模版采取的方式是正则表达式，除了，正则部分有点复杂之外，其他的还好。代码如下：

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;
using NewLife.Reflection;

namespace Micolog.Common.Template
{
    /// <summary>
    /// 简易模板，实现简单的模板替换
    /// </summary>
    /// <remarks>
    /// 简单变量替换:{$Date}
    /// 格式变量替换:{$Date:yyyy-MM-dd}
    /// 方法调用替换:{$GetDate(1,2,3),100}{$GetDate(1,2)}
    /// 方法调用格式替换:{$GetDate(1,2,3):0.00,100}{$GetDate(1,2):0.00}
    /// </remarks>
    public class Simple
    {
        private static readonly Regex SimpleTagReg = new Regex(@"\{\$(\w+)\}");
        private static readonly Regex FormatTagReg = new Regex(@"\{\$(\w+):([\w|\.]+)\}");
        private static readonly Regex MethodTagReg = new Regex(@"\{\$(\w+)\(([\w|,]+)\),([\w|\.]+)}");
        private static readonly Regex MethodFormatTagReg = new Regex(@"\{\$(\w+)\(([\w|,]+)\):([\w|\.]+),([\w|\.]+)}");
        private static readonly Regex MethodNotDefaultTagReg = new Regex(@"\{\$(\w+)\(([\w|,]+)\)}");
        private static readonly Regex MethodFormatNotDefaultTagReg = new Regex(@"\{\$(\w+)\(([\w|,]+)\):([\w|\.]+)}");
        private StringBuilder template;
        private String _Body;
        /// <summary>
        /// 模板内容
        /// </summary>
        public String Body
        {
            get 
            {
                return _Body; 
            }
            set 
            {
                _Body = value;
                this.template = new StringBuilder(value);
            }
        }
        ///// <summary>
        ///// 输出模板内容
        ///// </summary>
        ///// <returns></returns>
        //public override string ToString()
        //{
        //    return this._Body;
        //}
        private Dictionary<String,Object> _Parameters;
        /// <summary>
        /// 编译参数
        /// </summary>
        public Dictionary<String,Object> Parameters
        {
            get 
            {
                if (_Parameters == null)
                {
                    lock (typeof(Simple))
                    {
                        if (_Parameters == null)
                        {
                            _Parameters = new Dictionary<String, Object>();
                        }
                    }
                }
                return _Parameters; 
            }
        }

        private Dictionary<String, Func<String[], Object>> _Methods;
        /// <summary>
        /// 编译方法
        /// </summary>
        public Dictionary<String, Func<String[], Object>> Methods
        {
            get
            {
                if (_Methods == null)
                {
                    lock (typeof(Simple))
                    {
                        _Methods = new Dictionary<String, Func<String[], Object>>();
                    }
                }
                return _Methods;
            }
        }
        
        /// <summary>
        /// 载入模板文件
        /// </summary>
        /// <param name="path"></param>
        public void Load(String path)
        {
            this.Load(path, Encoding.UTF8);
        }
        /// <summary>
        /// 载入模板文件,并制定编码方式
        /// </summary>
        /// <param name="path"></param>
        /// <param name="encoding"></param>
        public void Load(String path, Encoding encoding)
        {
            using (var sr = new StreamReader(path, encoding))
            {
                this._Body = sr.ReadToEnd();
                this.template = new StringBuilder(this._Body);
            }
        }
        /// <summary>
        /// 载入模板字符串
        /// </summary>
        /// <param name="body"></param>
        public void LoadString(String body)
        {
            this._Body = body;
            this.template = new StringBuilder(body);
        }

        /// <summary>
        /// 编译模板
        /// </summary>
        public void Process()
        {
            //Regex
            if (this._Parameters == null) return;
            var map = new Dictionary<String,String>();
            //处理简单标签
            foreach (Match match in SimpleTagReg.Matches(this._Body))
            {
                var tag = match.Groups[0].Value;
                var name = match.Groups[1].Value;
                if (this._Parameters.ContainsKey(name) && !map.ContainsKey(tag))
                {
                    //如果参数中包含这个标签,就将这个标签加入缓存
                    map.Add(tag, this._Parameters[name].ToString());
                }
            }
            //处理格式化标签
            foreach (Match match in FormatTagReg.Matches(this._Body))
            {
                var tag = match.Groups[0].Value;
                var name = match.Groups[1].Value;
                var format = match.Groups[2].Value;
                if (this._Parameters.ContainsKey(name) && !map.ContainsKey(tag))
                {
                    map.Add(tag, String.Format("{0:" + format + "}", this._Parameters[name]));
                }
            }
            //处理方法标签
            foreach (Match match in MethodTagReg.Matches(this._Body))
            {
                var tag = match.Groups[0].Value;
                var method = match.Groups[1].Value;
                var parameters = match.Groups[2].Value;
                var defaultValue = match.Groups[3].Value;
                if (!map.ContainsKey(tag))
                {
                    if (this._Methods.ContainsKey(method))
                    {
                        var value = this._Methods[method](parameters.Split(',')).ToString();
                        map.Add(tag, value);
                    }
                    else
                    {
                        map.Add(tag, defaultValue);
                    }
                }
            }
            foreach (Match match in MethodFormatTagReg.Matches(this._Body))
            {
                var tag = match.Groups[0].Value;
                var method = match.Groups[1].Value;
                var parameters = match.Groups[2].Value;
                var format = match.Groups[3].Value;
                var defaultValue = match.Groups[4].Value;
                if (!map.ContainsKey(tag))
                {
                    if (this._Methods.ContainsKey(method))
                    {
                        var value = this._Methods[method](parameters.Split(','));
                        map.Add(tag, String.Format("{0:" + format + "}", value));
                    }
                    else
                    {
                        map.Add(tag, defaultValue);
                    }
                }
            }
            foreach (Match match in MethodNotDefaultTagReg.Matches(this._Body))
            {
                var tag = match.Groups[0].Value;
                var method = match.Groups[1].Value;
                var parameters = match.Groups[2].Value;
                if (!map.ContainsKey(tag))
                {
                    if (this._Methods.ContainsKey(method))
                    {
                        var value = this._Methods[method](parameters.Split(',')).ToString();
                        map.Add(tag, value);
                    }
                    else
                    {
                        map.Add(tag, String.Empty);
                    }
                }
            }
            foreach (Match match in MethodFormatNotDefaultTagReg.Matches(this._Body)) // .Matches(this._Body))
            {
                var tag = match.Groups[0].Value;
                var method = match.Groups[1].Value;
                var parameters = match.Groups[2].Value;
                var format = match.Groups[3].Value;
                var defaultValue = match.Groups[4].Value;
                if (!map.ContainsKey(tag))
                {
                    if (this._Methods.ContainsKey(method))
                    {
                        var value = this._Methods[method](parameters.Split(','));
                        map.Add(tag, String.Format("{0:" + format + "}", value));
                    }
                    else
                    {
                        map.Add(tag, defaultValue);
                    }
                }
            }
            foreach (var i in map)
            {
                this.template.Replace(i.Key, i.Value);//替换模板内容
            }
        }
        /// <summary>
        /// 保存处理结果
        /// </summary>
        /// <param name="path"></param>
        public void SaveAs(String path)
        {
            this.SaveAs(path, Encoding.UTF8);
        }
        /// <summary>
        /// 保存处理结果并制定编码方式
        /// </summary>
        /// <param name="path"></param>
        /// <param name="encoding"></param>
        public void SaveAs(String path, Encoding encoding)
        {
            if (this.template == null) throw new Exception("还未载入模板!");
            using (var sw = new StreamWriter(path, false, encoding))
            {
                sw.Write(this.template.ToString());
            }
        }
        public override string ToString()
        {
            return this.template == null ? this._Body : this.template.ToString();
        }
    }
}