如何用好IronPython

翻看了一下Tutorials，发现和以前的内容差不多，按照Tutorials中的方法尝试了一下在C#中嵌入IronPython 代码，发现还很不错，最起码可行，虽然速度肯定没有用C#直接写出来的快（因为IronPython需要动态编译的缘故）。

好的，现在我们拥有了一项较稳定的可以投入使用的新技术了，但是如果没有市场，那么这个新技术是不能够生存的，所以我左思右想 IronPython在企业级开发中到底占了什么地位（因为我是做企业级开发的:)），有何等优势呢？通过分析现有IronPython的特征，我得到了一个结论，那就是它比较适合做脚本引擎或者简单的客户端。以下是我分析的IronPython的一些特征：

1. Python的语法，灵活性相当的高！
2. 与.NET Framework的交互实现的非常的好，现在用Python的语法也可以用.NET的类库了。
3. 在其他.NET语言中可以通过引用IronPython.dll来执行IronPython文件并且可以实现内存共享（在同一AppDomain中）。
4. 纯IronPython程序启动非常慢。
5. 由于IronPython的特殊性，它所编译出来的程序集中的成员并非你所想象的，所以不能够由其他程序集直接引用使用。这主要还是因为Python是一种动态类型语言，所以无法在编译时给予合适的静态类型（唯一合适的就是System.Object）。另外为了与CPython保持兼容性，IronPython也是以module为单位进行group的，也就是一个module被编译成一个类，这个module中的所有成员，包括class都被当作成员编译在这个类中。

基于以上一些IronPython现有的特征来看，我觉得它更适合使用.NET 程序集，而非为.NET程序提供功能（虽然也是可行的，也是我希望的），所以我建议将IronPython用作客户端以及脚本引擎一类的用途上，因为这类程序是属于consumer类的，它们使用现成的API，但是它们不为其他人提供新的API。

如何用IronPython为.NET程序提供API

读者可能会说我自相矛盾，刚刚才说过IronPython不适合用来提供API，怎么现在又提起这件事来了呢（唉，人本身就是一种很矛盾的生物）？！其实就像上面我在括号中提及的，利用IronPython的交互能力与语言的灵活性为我的.NET程序提供简化的解决方案是我的期望，虽然速度方面还不尽人意，但优化的空间永远都是存在的，我相信随着时间的推移IronPython会在性能方面做的更出色（从这方面来看我是个乐观主义者:D）。

为了简化主程序与IronPython文件的交互与维护难度，我决定将IronPython文件作为服务（service）来看待，IronPython所提供的每一个API就是一个独立的服务，每次需要使用这个服务的时候我只需向它发送相应的消息（message）即可，而它，会返回给我一个回应（response）如果有必要的话。我觉得这样做比较符合目前的SOA潮流。（如果你还不知道SOA是什么的话，一句话告诉你，它是一种企业级集成手段）

我的做法很简单，只是初步实现了一个对IronPython文件调用的封装，示例如下。

 List<int> a = new List<int>();
 a.Add(1);
 a.Add(2);
 a.Add(3);

 List<int> b = new List<int>();
 b.Add(4);
 b.Add(5);
 b.Add(6);

 PyFacade<IList<IList<object>>> py =
    new PyFacade<IList<IList<object>>>();
 py.PythonFile = "mayorThenTen.py";
 py.Arguments.Add("listA", a);
 py.Arguments.Add("listB", b);
 py.Execute();

 foreach (IList<object> tuple in py.Result) {
    Console.Write(tuple[0]);
    Console.Write(", ");
    Console.Write(tuple[1]);
    Console.WriteLine();
 }

PyFacade的代码如下。

using System;
using System.Collections.Generic;

using IronPython.Hosting;

namespace Cavingdeep.Python {
   public class PyFacade<T> {
      public const string ResultVariableName = "_result_";

      private PythonEngine engine = new PythonEngine();

      private string pythonFile;
      private Result<T> result = new Result<T>();
      private IDictionary<string,object> args =
         new Dictionary<string,object>();

      public string PythonFile {
         get {return this.pythonFile;}
         set {this.pythonFile = value;}
      }

      public T Result {
         get {return this.result.Value;}
      }

      public IDictionary<string,object> Arguments {
         get {return this.args;}
      }

      public void Execute() {
         engine.Globals[ResultVariableName] = this.result;

         foreach (KeyValuePair<string,object> arg in this.args) {
            engine.Globals[arg.Key] = arg.Value;
         }

         engine.ExecuteFile(this.pythonFile);
      }
   }
}

Result的代码如下。

using System;

namespace Cavingdeep.Python {
   public class Result<T> {
      public T Value;
   }
}

mayorThenTen.py的代码如下，这是这个示例中用到的IronPython文件。

def mayorThenTen(a, b):
   return [(x, y) for x in a for y in b if x + y > 5]

if globals().has_key('_result_'):
   _result_.Value = mayorThenTen(listA, listB)

这里的这个PyFacade是个比较通用的与IronPython交互的接口类，在真正的应用中建议用强类型模式（强类型设计实践）加以封装以得到type safety等好处。

关于PyFacade是如何与IronPython文件交互一题，简单地说就是通过那个_result_变量，它会在IronPython文件中被赋值，这个值是外界可见的，也就是说IronPython文件的执行与当前程序是在一个AppDomain中的。有关这类知识感兴趣的读者可以去研究一下动态编译、加载与程序域（AppDomain）等知识。

当a的setx方法被调用时，会被“拦截”，先输出pre...然后是原始setx的方法调用，最后输出post...

看到那个__metaclass__变量了吗？如果你赋给它另外一个metaclass的话它会产生其他效应（我这里做的是 logging，其他的可能有例如timing、access control、transaction, etc.），这是魔法！^_^ 最魔力十足的地方是我甚至可以把一个metaclass传进模块中去，给__metaclass__动态的赋值（赋metaclass），这意味着我可以通过meta-programming动态的改变我程序的逻辑，或者不需要改动原有代码即可添加新功能（或修改）等特点！

整个演示就当作抛砖引玉吧，代码我就不细讲了，因为概念太复杂了，不是一两句能说得明白的。有兴趣的朋友可以研究一下Python。; -)

该不该使用Generics实现Abstract Factory？

我的意见是不应该，理由如下：

1. 具体创建对象的时候，也就是在ConcreteFactory中，不是所有情况都是简单地一个new操作就算是创造对象了，就像它的名字所示那样，具体对象具体操作，这里不能泛化，一定要根据具体类型来实现对象创建。
2. 就像许多人提到的，到底用多少个type variable才算合适呢？AbstractFactory<A, B>, AbstractFactory<A, B, C> ??? 简单地说，Abstract Factory是不能够定量的，目前.NET与Java的泛型都不能实现这点。

Java的泛型真的那么弱吗？如果要实现定量的Abstract Factory真的很难吗？

我的答案是否，实际上，我觉得用Java的语法无论在实现上的阅读与易用性都要比.NET的语法强。下面是我给出的Abstract Factory的实现，虽然我说过，用Generics实现Abstract Factory并不合适。

interface Processor {}

interface Ram {}

class PentiumProcessor implements Processor {}

class DDRRam implements Ram {}

interface AbstractFactory<PA, PB> {
   PA createA();
   PB createB();
}

class IntelFactory implements AbstractFactory<PentiumProcessor, DDRRam> {
   public PentiumProcessor createA() {
      // 一切特化且可在这里实现。
      return new PentiumProcessor();
   }

   public DDRRam createB() {
      // 一切特化且可在这里实现。
      return new DDRRam();
   }
}

// 使用
AbstractFactory<? extends Processor, ? extends Ram> factory =
   new IntelFactory();
      
Processor processor = factory.createA();
Ram ram = factory.createB();

以上代码并没有运用不必要的TypeToken，而且也没有实例化时特化的问题，但是仍然没有解决Abstract Factory的量的问题。可以看出，这段代码非常的简洁，我觉得这段代码真正突出了Generics的优点：泛化类型，而没有做不应该做的过多的事情（比如泛化本来应该是特化的东西）。

注意Java的Generics语法是可以使用wildcard的（?），这是.NET所没有的。wildcard的特点之一就是能够在变量声明中使用，这是很重要的一大特色。

我这里简单描述一下现有功能，有兴趣的朋友请自行下载。

1. 使用简便切容易扩展的模板引擎。
2. 提供基于ASP语法的模板语言，简单易上手。
3. 扩展ASP的DTL（Dynamic Template Language）模板语言。现在写模板终于变得简单易维护了！
4. 内置Dcg对象，提供模板自身信息。
5. 完美自控资源清理，不会在您的目标系统上留下任何痕迹。
6. 安全的动态模板执行，运行DCG动态模板不会危及到您的系统，您尽可放心运行从第三方获得的DCG动态模板，因为DCG模板的运行权限要比Internet程序还要低。
7. 调试支持，开启调试后您将可以获得详细到行与列的错误提示信息。
8. 最后但却很重要的一项，DCG很快并且内存占用很优化，您尽可以放心的在你的程序中使用大量DCG动态模板。

我会在今后的一些时日中仔细描述每一个功能以及使用，同时我会告诉你它们能给你带来什么样的价值。

http://dcg.tigris.org

有需要的朋友们赶快自取吧。

《改进ASP语法打造更高效的模板语言》

《改进ASP语法打造更高效的模板语言II》

项目首页
http://dcg.tigris.org

文档页
http://dcg.tigris.org/doc.html

另外模板引擎的使用帮助也已经被写在了SDK帮助中，你可以通过获取最新的源代码获得，获取后用NAnt编译生成文档。如果在使用上有什么问题的话请通过此Blog与我联系。

让我们来看一个例子，假如我想输出以下内容：

int[] numbers = new int[] { 1, 2, 3, 4, 5 };

注意空格哦！这里的动态部分就是从1到5的这部分。模板要怎样写呢？可以这样：

int[] numbers = new int[] { <%
for (int i = 1; i <= 5; i++) {
   if (i < 5) {
      <%!
      <%=i%>, 
      !%>
   } else {
      <%!
      <%=i%>
      !%>
   }
}
%> };

int[] numbers = new int[] { <%=template1=%> };

<%# template1
for (int i = 1; i <= 5; i++) {
   if (i < 5) {
      <%!
      <%=i%>, 
      !%>
   } else {
      <%!
      <%=i%>
      !%>
   }
}
#%>

呵呵，不错，就是这个样子，这就是我想要的。嗯，<%# templateName #%>就是所谓的模板标签，它定义了一个动态模板，<%=templateName=%>就是模板引用，将被引用的模板结果输出到引用位置上。

这下清晰多了，而且模板可以被多个地方引用，达到一定程度上的可重用性。这套机制酷似XSLT中的template标签，不过没有模板参数等的定义。也许你会问：“那我可以传参数给模板标签吗？”可以，不过准确的说不是你手动传，是自动传的。换句话说，模板引用是一个Closure，模板标签中的内容在运行时会自动获得所有模板引用当前的上下文。比如如下示例：

<%# t1
   if (var) {
      <%!
      OK
      !%>
   } else {
      <%!
      oh, no
      !%>
   }
#%>
<%
   bool var = true;
   <%!
   First time call's result is <%=t1=%>.
   
   !%>
   
   var = false;
   <%!
   Second time call's result is <%=t1=%>.
   !%>
%>

输出为：
First time call's result is OK.
Second time call's result is oh, no.

好了，这篇的内容就介绍完了，不知道我所描述的这两大DTL语法有没有引起你的足够兴趣，再次说明一下，如果你已经感兴趣了的话，可以自己下载试一下哦。在《改进ASP语法打造更高效的模板语言》一篇中有相关链接。

Hello <%=employee.Name%>.

如何将静态与动态这两部分很好的混合在一个模板中一直是动态模板的易用性关键，比如如果我想输出从1到5，以逗号分隔这样的文字时我可以用以下写法：

<%
int length = 5;
%>
<%
for (int i = 1; i <= length; i++) {