StringTemplate属性范围 模板引用

属性范围：
StringTemplate的文档：
Reference to attribute a in template t is resolved as follows:
1. Look in t's attribute table 在自己的属性里面找
2. Look in t's arguments 在参数里面找
3. Look recursively up t's enclosing template instance chain 沿着模板嵌套链向上找
4. Look recursively up t's group / supergroup chain for a map 在group/supergroup链的map里面搜索

同一个模板，可能会被在多个模板中调用，那这个模板所需要的参数，需要慎重考虑如何设置。
1. 在模板嵌套链的上一层、上上一层...设置，通过模板调用自然传递下来。
2. 上一层模板使用参数方式传过来。
属性查找采用就近原则，即在搜索路径上，找到第一个就停止。所以需要关注属性的传递、覆盖问题。
StringTemplate里面有个Formal Argument的概念，还不清楚怎样使用，但可以肯定它跟属性的范围、传递相关的。

一个属性范围相关问题的解决方案

上面这样一个显示商品的html块，可以提取成一个模板item.st。当页面需要显示多个商品时怎么办？
$items: {<div>$item()$</div>}$这样的方法看似能够解决问题，但是它只适用于在一排显示4个、5个商品这样的情况，如果我需要在页面的不同位置显示这几个商品呢？
我的做法是提供一个界面定义item1.st、item2.st...，他们都使用item.st这个模板，并且让用户选择一个要显示的商品。item1.st、item2.st...的内容: $item()$，它们都只是调用一下item.st这个模板，程序根据item1关联的商品，可以把这个商品加载出来，把商品属性设置在item1上。这样，在开发时就可以在界面的任意位置使用类似$item1()$、$item2()$这样的方法，显示不同的商品了。
这种情况下，item.st类似于一个类，而item1.st、item2.st等类似于类的不同实例了。

模板引用：
创建一个StringTemplateGroup后，他会集中管理各个StringTemplate对象，StringTemplateGroup内部使用一个Hashtable缓存已经加载、定义的ST对象。
group.LookupTemplate(string name): 直接加载ST对象，或者从缓存中获取，将ST对象的直接引用返回给调用者。
group.GetInstanceOf(string name): 加载ST对象，或者从缓存中获取，将ST对象作一份DeepCopy（不包括Attributes、EnclosingInstance）返回给调用者。
这个区别就很明显了，如果对LookupTemplate返回的对象进行修改，StringTemplateGroup内部缓存的那个也被修改了；而GetInstanceOf则不会。有的时候你需要使用DeepCopy的实例，而有的时候需要直接使用缓存的那个，根据具体情况决定使用哪个方法了。

看一下这样一个需求:
a.st: $b()$
b.st: $c()$ - $attrB$
c.st: $attrC$
工作代码类似这样:

StringTemplateGroup group = new StringTemplateGroup("test", @"c:\test");
StringTemplate a = group.GetInstanceOf("a");
StringTemplate b = group.LookupTemplate("b");
StringTemplate c = group.LookupTemplate("c");
b.SetAttribute("attrB","test attr B");
b.SetAttribute("attrC","test attr C");
Assert.AreEqual("test attr C - test attr B", a.ToString());

这段代码无法得到预期的结果，因为StringTemplate在a.ToString()方法解析过程中，使用GetInstanceOf方法获取b.st、c.st这两个模板对象，也就是使用了缓存对象的一个DeepCopy版本，没有包含Attributes。
在这个简单的例子里面，可以在用a.SetAttribute()设置attrB、attrC属性来解决。不过我的情况比较复杂，必须要改变StringTemplate对象的这个行为，所以我修改了原代码来实现。
在StringTemplateGroup.cs里面

public virtual StringTemplate GetEmbeddedInstanceOf(StringTemplate enclosingInstance, string name)

修改成

public virtual StringTemplate GetEmbeddedInstanceOf(StringTemplate enclosingInstance, string name)
{
    StringTemplate st = null;
    // TODO: seems like this should go into LookupTemplate
    if (name.StartsWith("super."))
    {
        // for super.foo() refs, ensure that we look at the native
        // group for the embedded instance not the current evaluation
        // group (which is always pulled down to the original group
        // from which somebody did group.getInstanceOf("foo");
        //modified by RicCC, 08.22.2007
        //st = enclosingInstance.NativeGroup.GetInstanceOf(enclosingInstance, name);
        st = enclosingInstance.NativeGroup.LookupTemplate(enclosingInstance, name);
    }
    else
    {
        //modified by RicCC, 08.22.2007
        //st = GetInstanceOf(enclosingInstance, name);
        st = LookupTemplate(enclosingInstance, name);
    }
    // make sure all embedded templates have the same group as enclosing
    // so that polymorphic refs will start looking at the original group
    st.Group = this;
    st.EnclosingInstance = enclosingInstance;
    return st;
}

方法里面的TODO注释也说明了作者在考虑应该使用LookupTemplate方法，应当是TODO忘了Review了，否则也不应当再把这个TODO留在这里。

看源代码发现的另外一个问题：
StringTemplate会监控*.st文件，如果文件有修改，会重新加载相应的ST对象，用它把原来内部缓存的对象给覆盖掉。假如你为内部缓存的对象设置好属性，调用StringTemplate开始解析，这个时候st文件被修改了，那么设置的属性就被丢弃掉了。不过模板被修改，对当前的解析过程肯定有影响；不监控模板文件的变化，也不合适。我根据自己的情况，还是选择在覆盖的时候，把原来的属性copy过来，这样符合我的需求。
把StringTemplateGroup.cs文件下面的方法改成这样就可以了

public virtual StringTemplate LookupTemplate(StringTemplate enclosingInstance, string name)
{
    lock (this)
    {
        if (name.StartsWith("super."))
        {
            if (superGroup != null)
            {
                int dot = name.IndexOf('.');
                name = name.Substring(dot + 1, (name.Length) - (dot + 1));
                StringTemplate superScopeST =
                    superGroup.LookupTemplate(enclosingInstance, name);
                return superScopeST;
            }
            throw new StringTemplateException(Name + " has no super group; invalid template: " + name);
        }
        StringTemplate st = (StringTemplate)templates[name];
        //added by RicCC, 08.20.2007
        IDictionary originalAttributes = null;  //added
        if (st != null)
        {
            // Discard cached template?
            if (st.NativeGroup.TemplateHasChanged(name))
            {
                //added by RicCC, 08.20.2007, discard the cached template, but save it's attributes
                originalAttributes = st.attributes;   //added
                templates.Remove(name);
                st = null;
            }
        }
        if (st == null)
        {
            // not there?  Attempt to load
            if (!templatesDefinedInGroupFile)
            {
                // only check the disk for individual template
                st = LoadTemplate(name);
            }
            if (st == null && superGroup != null)
            {
                // try to resolve in super group
                //st = superGroup.GetInstanceOf(name);
                st = superGroup.GetInstanceOf(enclosingInstance, name);
                // make sure that when we inherit a template, that it's
                // group is reset; it's nativeGroup will remain where it was
                if (st != null)
                {
                    st.Group = this;
                }
            }
            if (st != null)
            {
                // found in superGroup
                // insert into this group; refresh will allow super
                // to change it's def later or this group to add
                // an override.
                //added by RicCC, 08.20.2007
                if (originalAttributes != null)
                    st.attributes = originalAttributes;   //added, approach this by invoking SetAttribute() method?
                templates[name] = st;
            }
            else
            {
                // not found; remember that this sucker doesn't exist
                templates[name] = NOT_FOUND_ST;
                string context = "";
                if (enclosingInstance != null)
                {
                    context = "; context is " + enclosingInstance.GetEnclosingInstanceStackString();
                }
                throw new TemplateLoadException(this, "Can't load template '" + GetLocationFromTemplateName(name) + "'" + context);
            }
        }
        else if (st == NOT_FOUND_ST)
        {
            return null;
        }
        return st;
    }
}

其它问题：
从StringTemplate.Net源代码的一些主要处理过程来看，里面是存在不少缺陷的，一些处理方案比较粗糙，考虑的不够成熟完善，可能给系统带来隐患问题，特别是多线程的并发、冲突等方面的控制，基本就看不到一个全局清晰的解决思路。
所以，原来还以为可以全局共享同一个StringTemplateGroup对象，现在只能改成每个请求需要使用时，就新开一个StringTemplateGroup了，毕竟这样安全。

这一次在架构之前没有很好的掌握StringTemplate，吃了一点亏（加班、核心架构做了一次重大调整）。StringTemplate本身文档很少，要全面掌握它的使用方法，必须结合源代码，投入的精力比较大。
不过它的思想还是非常不错，一个开源项目要成熟下来，是需要大量的投入和时间，以及实践反馈的。基于这样一个状况，采用BSD协议也是它最好的一个选择了。现在看来，使用它解决我当前项目的问题，实在是最合适不过了，框架的核心部分简洁而又行云流水，扩展性非常强，StringTemplate本身的一些问题，后续再慢慢完善，也是非常值得的。