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本身的一些问题，后续再慢慢完善，也是非常值得的。