博客园-小蟒蛇IronPython

numpy和scipy终于可以直接用在.net上了

白途思 — Thu, 03 Nov 2011 16:08:00 GMT

科学计算语言，底层的当属fortran和C，上层的是matlab用户最多了，居然可以排进世界十大语言。
但是matlab的效率和部署问题，使得很多人只在其上进行算法开发、仿真、调试，之后还要用通用语言重写算法实现。
将matlab是商业软件，python作为一种开放的语言逐渐在科学计算领域流行起来。
numpy和scipy就是基于python开发的两个库。
其实还有很多其他科学计算软件。只是python作为一种通用脚本语言易用，易集成。
所以易用，是像matlab一样随写随运行，所谓易集成，就是可以使用很多其他领域开发的包，而不局限在科学计算领域。

python作为一种脚本语言需要解释器支持，一种是CPython，基于C语言开发的，跨平台性好，一种是Ironpython，基于.net语言开发的，和.net程序结合很好。
同一种语言可以运行在上面两个平台，但是上面两个平台的库互调用就很麻烦了。
比如numpy和scipy就是在CPython上开发的，用在ironpython里需要ironclad做转换。

现在numpy和scipy也做了在Ironpython上可以直接运行的版本，就是本文介绍的。
可以看这个
http://pytools.codeplex.com/wikipage?title=NumPy%20and%20SciPy%20for%20.Net

下面是转载的：

作为Python Tools for Visual Studio项目的一部分，NumPy和SciPy程序库已经迁移到.NET上了。这项迁移通过本地的C核心组合了C#和C接口，从而所有.NET语言都能够从中受益。

IronPython对NumPy和SciPy的端口是完整的.NET端口，并且包含了针对一般本地C核心的自定义C#/C接口。这意味着不仅IronPython能够使用所有功能，而且所有.NET语言—— 像C#和F#——也可以使用，它们只需要访问C#接口对象，或者有时需要从其它.NET语言解析IronPython表达式。这意味着多维数组对象（ndarray）可以在IronPython和C#或者F#代码之间平滑地传递。此外，ndarray对象实现了标准的IEnumerable接口，这让数组对象可以由现存的代码经常使用，即便不是特别针对NumPy 的代码也没问题。

NumPy是一种很低级别的API，用于在大型、多维数组和矩阵上执行数学运算。这个库最初叫做Numeric，是在1995年创建的，那仅仅是Python 1.0发布一年之后。采用当前名称的版本是在2005年创建的，那时这个产品组合了早先的版本和名为numarray的竞争对手的程序库。

SciPy是在其基础之上构建的。据维基百科上所说，“SciPy包含很多模块，能够用于优化、线性代数、整合、插入、特定函数、FFT、符号和图像处理、ODE解析器以及其它科学和工程领域的一般任务。” 人们经常会考虑把它作为MATLAB的替代方案，尽管SciPy经常需要与其它库组合才能够完全替代MATLAB。

NumPy和SciPy的组合为一般的.NET代码提供了很多显而易见的优势。.NET的垃圾回收程序能够比手动的内存管理提供更好的性能，还有就是，通过高度优化的C代码，我们可以获得很好的计算速度。

在此之上还有视图的概念。NumPy不会复制数组，而是让我们可以创建作为其他数组子集存在的数组。改变子集（也就是所说的视图），也会改变原始的数组。这让我们可以在不牺牲性能的情况下获得更整洁的代码。

查看英文原文：NumPy and SciPy for .NET

作者: 白途思发表于 2011-11-04 00:08 原文链接

评论: 1　查看评论　发表评论

最新新闻：
· Jon Rubinstein 暂别科技舞台：再见，HP(2012-01-28 21:36)
· 塞班3设备更新换代诺基亚Belle出货(2012-01-28 21:34)
· 推土机Windows 7补丁权威测试(2012-01-28 19:24)
· 诺基亚在印度：品牌优势，渠道特点，跟中国的对比(2012-01-28 19:21)
· 世界最早的计算机密码和黑客(2012-01-28 19:20)

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

在.NET上进行线性代数等科学计算

redmoon — Tue, 29 Mar 2011 14:19:00 GMT

对于工程类、图形等专业软件，需要大量的数学计算，而用的最多的就是线性代数的计算。

那么，在.NET之上，尤其.NET 4.0和VS2010之上要如何完成相关的线性代数计算呢？我想有如下几种方式：

一，自己动手、丰衣足食：根据自己软件的需要，增量式地逐步开发一些函数库。这种方式最大的问题是——重新制作轮子，所以大部分一般不宜采用这种方式。

二，使用开源（或免费的）组件：这种方式的好处是有很多优秀的开源（或免费）的工具可选择，缺点是使用起来需要较大的学习成本

三，使用商业组件：这种方式相对于第二种的好处是，支持和服务上有所保障，缺点不言而喻就是费用较高。

下面，我将重点介绍中.NET平台上有什么用的开源（免费）组件可用。

1，使用F#进行开发

F#作为一门混合语言（函数式语言+面向对象语言），从一开始就是具有进行数学计算的优势。不仅编写计算代码更自然，F#的函数库也为数学计算提供了很好的支持。

在F#的powerpack中包含有Microsoft.FSharp.Math的命名空间就是专门用于数学计算的。其中提供了matrix类型——一种在进行线性代数计算中非常常用和重要的类型。

关于matrix类型可以阅读这里的帮助。也可以参考这个博客：http://fdatamining.blogspot.com/2010/03/matrix-and-linear-algebra-in-f-part-i-f.html

但是，要进行高效的线性代数计算，F#还需要借助外部的函数库，不过F#已经提供了相应的接口方便外部函数库集成进来，即是FSharp.PowerPack.Math.Providers.dll（这个程序集只有在FSharp-1.9.7.8中才有）。

比如，F#可以集成LAPACK（LAPACK，其名為Linear Algebra PACKage的縮寫，是一以Fortran 程式語言寫就，用於數值計算的函式集。 LAPACK提供了豐富的工具函式，可用於諸如解多元線性方程式、線性系統方程組的最小平方解、計算特徵向量、用於計算矩陣 QR分解的Householder轉換、以及奇異值分解等問題。在NetLib亦提供了API經簡化的Fortran 95版本的LAPACK95。LAPACK以BSD授權的方法釋出。）

具体的集成方式可以参考：http://fdatamining.blogspot.com/2010/03/matrix-and-linear-algebra-in-f-part-ii.html，http://fdatamining.blogspot.com/2010/03/compiling-lapack-for-net-usage.html

关于如何在F#中进行代数运算，这里有一个例子：http://fdatamining.blogspot.com/2010/04/matrix-and-linear-algebra-in-f-part-iii.html

其实，我上面引用的博客地址：http://fdatamining.blogspot.com/都是值得一读的。

2，使用IronPython进行开发

Python虽然不是函数式语言，但是其动态语言特性和代码风格也被很多人用来进行工程开发。而在Python之上有一个很著名的数学计算库——NumPy和SciPy，它也被移植到了.NET之上（移植的过程是在微软的帮助下）。

要使用这两个库，最好的就是通过Python Tools for Visual Studio——一个在VS2010中实现的Python集成开发环境来使用。

具体的使用向导可以访问：http://pytools.codeplex.com/wikipage?title=NumPy%20and%20SciPy%20for%20.Net

3，使用C#进行开发

在.NET 4.0中，加入了System.Numerics命名空间，为数学计算提供了一定的基础，但是.NET中还是没有内置线性代数的计算函数库。不过要使用C#开发，上面提到的LAPACK和SciPy都可以用。

对于LAPACK，也有.NET的版本，就是：DotNumerics

当然，还有很多第三方的开源、免费和商业的组件可用。

下面就来看看，还有那些组件：

Extreme Optimization Numerical Libraries for .NET（商业）
.NET Matrix Library（商业）
NMath .NET（商业）
NAG Library for .NET（商业）
SCINET（商业）
Math.Net（开源）
Dambach Linear Algebra Framework（开源）
ILNumerics.Net（开源）
Mapack（开源，我们的LCA软件就是使用的这个，其实我做了一个Provider可以任意切换到其他函数库上，后面我会再写篇博客来介绍）
Meta.Numerics（免费）

另外，对于使用哪种语言来进行科学计算开发，可以参考这篇博客的一些论述：C#-F#-Ironpython与科学计算，当然个人觉得F#和IronPython都适合进行科学计算。

作者: redmoon 发表于 2011-03-29 22:19 原文链接

评论: 6　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

谈谈Ironpython的应用

白途思 — Mon, 14 Mar 2011 13:30:00 GMT

关注Ironpython很久了，但是一直也没有应用的场合。

不同于python的广泛应用，Ironpython真的是雷声大雨点小。宣传、简介铺天盖地，貌似很有前途。

实际上，我真的很少有用到ironpython的情况。ironruby也是如此。

曾经尝试用Ironpython来写程序，但是其调试非常复杂。

好在和VS2010结合比较早，调试还算方便。可是关键的问题是，如果我用了VS2010，我干嘛不直接用C#，其开发和调试能力有目共睹。

至今，我能够使用Ironpython的地方只有一处，那就是NEUT，一个个人开发的小软件。

在处理搜索字符串拼接问题上，我使用了ironpython。

为什么呢？因为搜索字符串拼接，随着不同的网站有不同的方式，比如google scholar、SFX等等，都不尽相同。

您可能会问为什么不使用配置文件？因为搜索字符串使用到的数据，也是不尽相同，有的需要的是ISSN号，有的需要标题。甚至还要做大小写转换，以及特殊符号替换处理。配置文件处理起来太麻烦。

采用Ironpython，很轻松就处理了，毕竟是程序而不是配置文件，我可以很便捷的根据不同的网站进行字符串拼接。

其实，有很多软件的配置文件，也是用python写的。

ironpython的使用十分不便，调用python程序，还需要一些辅助模块，害的我处理了很久。

当然，如果只是ironpython使用dotnet功能还好点。

问题是dotnet的类名、方法名都很长！如果没有IDE的帮助，我很难记起全称……

所以说ironpython，中看不中用。

另外，ironpython作为脚本语言，适合处理运行时变化的情况。就是说进程不关闭，改变脚本，有不同的结果。

如果python程序驻留在进程里，就非常的麻烦，也失去其特长。

比如我有一次写了一个类扩展dotnet接口，然后用dotnet反射加载。这样这个对象就驻留在内存里。

如果我不关闭程序，或者重启ironpython的runtime，我改变ironpython文件是没有意义的，还是会按旧程序运行！因为这个对象没有消亡。

相反，如果仅仅是个方法，调用完了就接触python程序任务，那真是方便。毕竟不用重启主程序。

作者: 白途思发表于 2011-03-14 21:30 原文链接

评论: 0　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

三言两语话委托

FantasySoft — Sun, 16 May 2010 08:18:00 GMT

几天前，Michael向大家推荐了刚发布的IronPython Tools for Visual Studio。不知道这个消息是否能够为大家学习IronPython注入少许动力呢？有了IDE的支持，Michael的学习热情也随之高涨了，把若干年前的随笔翻箱倒柜的看了个遍，那个感慨啊……对技术充满激情的岁月或许再也回不去了。咳，别感春悲秋嘛，这可是在写技术随笔哦！好吧，让我们回归正题。

在翻箱倒柜过程中，我看到了在2007年2月发表的《不谈模式，只谈实现》。这是受到Justin一篇美文的启发，我所写的当年唯一一篇有关程序设计的文章。对于这篇随笔，老赵给我留下了这样的评论：

“这就是动态语言啊，相当于保留函数指针。
C#里面很像函数指针的是什么的呢？就是delegate。
而delegate的典型应用是什么呢？就是事件机制。
那么Java里的事件机制是怎么做到的呢？就是定义EventListener然后实现相应的方法。这就是和那个OO的Duck类似的实现了，一个Duck和一个EventListener在这个方面有些接近。
如果不熟悉Java的Event Listener的话也可以用传统的Observer模式来看，而且其实Event Listener等等，其实不就是用了Observer模式嘛。”

说实在话，由于自己水平有限，偶对这个评论并不能完全理解，特别是老赵提到了我并不是非常熟悉的delegate。到三年后的今天，偶再次阅读这条评论的时候，不得不由衷赞叹：老赵的评论字字珠玑！对于偶这个Java开发者来说，委托（delegate）是一个相对陌生的概念，即便是动态代理也并非委托在Java世界里的孪生兄弟。事实上，Java语言为什么能够如此流行，抛弃了难以驾驭的指针，降低了学习门槛是重要原因之一。但是，没了指针，也直接导致无法使用函数指针，这让很多C++开发人员使用Java就等于丧失了大半功力。C#作为Java后来者，在灵活性和简单之间取得了良好的平衡点，譬如，在方法参数上，Java只能传值，而C#既可以传值也可以传引用。对于函数指针，C#则创造了新的机制与之对应——那就是委托了。如果您和我一样，对委托了解得不够深入的话，建议您将JimmyZhang的经典文章——《C# 中的委托和事件》反复研读几遍，就会对委托有充分的了解了。如果您也和我一样，对为什么需要委托也心存疑虑的话，建议您阅读老赵的美文——《高阶函数、委托与匿名方法》，这也是一篇值得反复品味的文章。看了上述两篇文章之后，我们可以得出这样的结论：委托类型实现了强类型函数指针的功能，通过委托类型，我们可以将某个函数封装起来作为另外一个函数的参数。这个特点在函数编程语言（譬如IronPython）中则不是什么新鲜事了，对照《C# 中的委托和事件》中的第一个完整的范例，使用IronPython实现之：

>>> def EnglishGreeting(name):
...     print("Morning," + name)
...
>>> def ChineseGreeting(name):
...     print("早上好," + name)
...
>>> def GreetPeople(name, MakeGreeting):
...     MakeGreeting(name)
...
>>> GreetPeople("Jimmy Zhang", EnglishGreeting)
Morning,Jimmy Zhang
>>> GreetPeople("张子阳", ChineseGreeting)
早上好,张子阳

由于IronPython是一门动态语言，并且支持函数编程范式，所以我们可以直接将函数（方法）作为参数传递给另外一个函数（方法）。而在C#中，要实现这一点就需要使用委托类型了。

接下来，既然C#创造了委托类型，那么它的应用又在哪呢？是的，正如老赵的评论所言，事件机制是委托最典型的应用。有很多朋友都会觉得委托的使用有些多此一举，直接调用不就好了，那么兜兜转转干嘛呢？实际上，如果您希望直接调用也没啥问题，但是当需求改变的时候，您发现代码有无数的地方需要修改，那个时候就估计一个头两个大了。通过委托，我们可以更好地实现Observer模式，而这个模式定义了对象之间一对多的依赖关系，当一个对象改变了状态，那么所依赖的多个对象就会收到通知并且更新状态。要更好地了解Observer这个模式，除了《C# 中的委托和事件》中的讲解之外，仍旧是JimmyZhang的力作——《重温Observer模式--热水器·改》。文中给出了不使用委托实现Observer的方法，大家可以对比一下，繁简立现！看到文中IObservable接口的Register(IObserver obj)和Unregister(IObserver obj)方法，大家会联想到什么？是的，就是在.NET事件机制的典型应用当中，经常出现的+=和-=操作符，它们的作用在于更改委托对象所引用的方法列表。如果不使用委托，那么我们并不能直接对引用的方法列表进行操作，而要面向接口进行编程了。而对于IronPython来说，既然函数是一等公民，可以作为方法的参数，那么通过list的append方法就能轻松操作引用的方法列表了。参照JimmyZhang的两篇文章，我们也可以使用IronPython实现类似的热水器功能：

def makeAlarm(temperature):
    print("Alarm: " + str(temperature))


def showMsg(temperature):
        print("Display: " + str(temperature))


class Heater:
    def __init__(self):
        self.event = []
    def boilWater(self):
        for i in range(1,100):
            self.temperature = i
            if self.temperature > 95:
               [m(self.temperature) for m in self.event]


heater = Heater()
heater.event.append(makeAlarm)
heater.event.append(showMsg)
heater.boilWater()

上述代码中的[m(self.temperature) for m in self.event]使用了IronPython强大的列表内涵特性，self.event是一个list，其中的元素就是makeAlarm和showMsg这两个函数。通过m(self.temperature)就能够以self.temperature为参数调用上述两个函数了。大家是否觉得使用IronPython所编写的代码会更加短小精悍呢？

综上所述，如果您不明白什么是委托，那么您可以把它看作强类型的函数指针；如果您不知道什么是函数指针，那么您可以把它看作将函数（方法）作为参数传递的一种机制；如果您不了解为什么需要委托，那么您可以参考一下使用与不使用委托来实现Observer模式之间的区别；如果您不知道为啥需要Observer模式，那么您可以进而了解一下Law of Demeter；如果您仍然不知道为啥需要遵循Law of Demeter，那么您就可以思考一下封装性为啥是面向对象编程核心要素之一了。

作者: FantasySoft 发表于 2010-05-16 16:18 原文链接

评论: 2　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

IronPython Tools——为IronPython度身定做的IDE

FantasySoft — Tue, 11 May 2010 01:26:00 GMT

虽然对于IronPython的开发者来说，打开一个命令行窗口（Console）噼里啪啦地往里写代码是一件很Cool的事情，但是，要让IronPython成为.NET上一等公民，没有IDE的支持多少有点痴人说梦的感觉。Visual Studio 2010在上个月12号全球同步发布了，一直用着Beta 2版本的Michael还指望着正式版能够提供对IronPython的支持，结果希望落空了。在IronPython Studio已然成为鸡肋的时候，Michael对一个能够支持IronPython最新版本的IDE可谓望眼欲穿了。事实上，IronPython Team早在今年二月份举行的PyCon 2010上就曾宣布他们将在今年内发布IronPython Tools for Visual Studio（简称IPyTools）。它是以插件的形式出现，安装之后，开发者就能用Visual Studio开发和调试IronPython程序了。最近，该IronPython Tools终于透过IronPython的官方网站发布了！

要使用IPyTools，我们并不需要完整的Visual Studio 2010。得益于良好的设计和扩展性，我们只要安装160多MB的Visual Studio 2010 Shell作为IPyTools的运行环境即可。在此，Michael选择的是Visual Studio 2010 Shell的Integrated版本，而非Isolated版本。至于两个版本的区别，您可以从这里了解到。在安装了Visual Studio 2010 Shell之后，Michael下载了IPyTools——一个只有3.3MB的.vsix文件，双击该文件，出现如下的窗口：

勾选你希望集成的运行环境，点击Install。至此，一个Look and Feel与Visual Studio完全一致并且功能强大的IronPython IDE就安装完成了。之所以选择Visual Studio 2010 Shell与IPyTools搭档，因为这样的组合是完全免费的。特别说明一下，IPyTools可以安装至任何一个版本Visual Studio 2010，Express版本除外。

利用IPyTools，我们可以轻松创建Console、WinForm、WPF等项目；在代码编辑器里，最常见、最实用的Intellisense、Go To Definition和Find All References等功能自然不在话下；调试功能对设置断点、变量查看、栈查看、指令跳转等提供了良好的支持；更重要的是，我们在IDE里还能打开交互式窗口，对一些信手拈来的代码进行调试，这是不是很Cool呢？

看到这个功能，Michael不由得想起了若干年前自己开发的一个玩具般的IDE——FantasyPython，当时大费周章地实现了命令行窗口与WinForm的集成，由于能力有限，FantasyPython很快就夭折了，开发一个IronPython IDE的愿望也随之破灭了。当时并没有Visual Studio Extension开发的机制，这让开发IDE成为了不可能的任务。而现在，有了Visual Studio Shell，我们在其基础上开发插件，就能得到定制的IDE了。说到这里，Michael不由得感慨：技术革新是第一生产力啊！

正如IronPython Team在Release Notes所说，IPyTools现在只是一个社区技术预览版本，还有很多地方需要改进。IronPython官方网站上提供了一份IPyTools的技术说明书，我们从中能够了解到IPyTools最终是个什么样子，为它的改进提出自己的反馈意见。工欲善其事，必先利其器，现在IPyTools来了，恰是学习IronPython好时机，一起来吧！

作者: FantasySoft 发表于 2010-05-11 09:26 原文链接

评论: 11　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

lambda与闭包

FantasySoft — Mon, 03 May 2010 08:43:00 GMT

在《作为.NET程序员，您需要IronPython么？》一文中，Michael给大家介绍了IronPython的诸多优点，其中的一条就是IronPython实现闭包要比C#和VB.NET来得更为直观。在文中，针对“找出长度较短的字符串”的功能，我给出了IronPython的代码：

>>> SampleData = ["the", "quick", "brown", "fox", "jumped","over", "the", "lazy", "dog"]
>>> maxLength = raw_input("Maximum length of string to include?")
>>> maxLength = int(maxLength)
>>> shortWords = [i for i in SampleData if len(i) <= maxLength]

这段代码的核心在于最后一个赋值语句，它是典型的列表内涵（List Comprehension）的应用。而事实上，这个赋值语句等价于以下的代码：

shortWords = filter(lambda i: len(i) <= maxLength, SampleData)

使用这样的代码也许和C#和Java的闭包－Jon谈《The Beauty of Closures》一文中C#代码具有更强的可比性，因为lambda是Python中用于定义匿名函数的关键字，而匿名函数又是实现闭包的充分条件之一（非必要条件）。在讨论闭包和lambda之前，我们先来了解一下filter函数。

filter(function, sequence)函数是Python的内建函数，我们无需引入任何的包（package）即可使用。它实现了将序列中某些符合条件的元素筛选出来的功能；它需要两个参数：第一个是函数，用于定义筛选条件；而另一个则是序列，作为被筛选的对象。Python Tutorial给出的示例代码可以帮助我们更好地理解filter这个函数。

现在，您对filter函数有一定的认识了吧？那么让我们再回到上述的赋值语句。lambda定义了一个匿名函数，它返回了一个布尔值：True或者False，而判断条件则是：参数的长度小于或者等于maxLenth。在这里，lambda充其量只是一个语法糖，让代码更加易读，并没有体现出它与闭包的关系。说到这里，您一定会问：到底什么是闭包呢？从定义上来说：闭包就是由函数与其相关的引用环境组合而成的实体。如果一门语言很好地支持闭包，那么它需要具备以下条件：
    • 函数是语言的一等公民，它不从属于其它任何对象，可以作为方法的返回值；
    • 函数可以嵌套定义；
    • 可以捕获引用环境，并把引用环境和函数代码组成一个可调用的实体；
    • 允许定义匿名函数。
基于上述条件的第三点，我们可以将上述代码改写为如下形式：

>>> SampleData = ["the", "quick", "brown", "fox", "jumped","over", "the", "lazy", "dog"]
>>> def filterFunc(maxLength):
... return lambda i: len(i) <= maxLength
>>> maxLength = raw_input("Maximum length of string to include?")
>>> maxLength = int(maxLength)
>>> shortWords = filter(filterFunc(maxLength), SampleData)

我们回头对照一下上述的条件，filterFunc不正是闭包的最好体现么？也许您会觉得我有点画蛇添足，多此一举，但是，我们确实拥有了一个极具灵活性的可调用实体。如果要筛选出最大长度为4的单词，我们可以这么做：

fourLetter = filter(filterFunc(4), SampleData)

如果要筛选出最大长度为3的单词，我们又可以这么做：

threeLetter = filter(filterFunc(3), SampleData)

我们回想一下面向对象编程当中的函数，它的定义是固定的，不会在运行时发生变化。而闭包则不同，它会根据不同的引用环境发生变化，从而返回不同的函数实例。因此，我会把闭包等同于返回值是函数的函数，而lambda的存在可以让返回的函数定义得到简化。更多有关闭包的介绍，请参考园子里的季方亮同学的文章——《函数编程之闭包漫谈(Closure)》；有关lambda的介绍，则请参考CoderZh同学的文章——《Python天天美味(35) - 细品lambda》。

最后，也许有朋友会问：我们为什么需要lambda和闭包呢？这是为了将side-effect降至最低，也就是将变量从我们代码当中剔除！我想您一定会对此很惊讶，但这是事实，最纯粹的函数式编程是只有定义的。基于此，最开始的代码还能演变成如下所示：

>>> SampleData = ["the", "quick", "brown", "fox", "jumped","over", "the", "lazy", "dog"]
>>> raw_input("Maximum length of string to include?")
>>> print(filter(lambda i:len(i) <= int(_), SampleData))

对编程范式感兴趣的朋友，可以参考我的文章：《说的都是概念——有关编程范式》。

作者: FantasySoft 发表于 2010-05-03 16:43 原文链接

评论: 6　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

由XML Literal引发的思考

FantasySoft — Fri, 23 Apr 2010 16:21:00 GMT

一年多没在首页露脸了，昨天凌晨写就了一篇有关IronPython的随笔，发布的时候我确实有点诚惶诚恐。不过还好，至少引得几位朋友的围观，还能碰上老朋友木野狐，我心足矣！木野狐在评论中给我留下了一个非常棒的问题：“IronPython能否模拟或者接近vb.net的xml literal那样的语法？”尽管我对IronPython处理XML的能力自信满满，但是，面对XML Literal这样的词汇，我有点踌躇了。于是，我开始了一系列的研究。

首先，什么是XML Literal呢？原来，这是在VB.NET 9.0才引入的一个用于构建XML对象的新特性，并且只有VB.NET 9.0才支持。我们都知道，要创建XML树，可以使用Linq中的API，如下所示（代码出自VB.NET 9.0: XML Literal）：

Dim _xml2 = New XElement("ProcessList", _
New XElement("Process", _
New XAttribute("ThreadCount", "2"), "Some Process"))

对于上述的代码，我们可以使用更简单的方式进行赋值，那就是直接将XML树写出来：

Dim _xml = <Processes>
<Process ThreadCount="2">Some NameProcess>
Processes>

这就是VB.NET特有的XML Literal了。这个特性不仅仅简化了XElement构建的过程，更重要的是，我们可以在构建的过程中添加某些查询！譬如下面的代码（代码出自XML Literals Overview）：

Dim contact2 =
        <contact>
          <name>Patrick Hinesname>
          <%= From p In phoneNumbers2
            Select <phone type=<%= p.Type %>><%= p.Number %>phone>
          %>
        contact>

看到这些例子，我着实被震撼了。VB.NET对XML的支持力度可谓空前绝后了，甚至一些忠实的C#拥趸都因此拜倒在VB.NET的石榴裙下。C#社区也纷纷要求为C#增加XML Literal特性，更有甚者竭力找到了Anders为大家留下的后门。对于XML Literal有兴趣的朋友，可以阅读以下几篇来自MSDN的文章：XML Literals Overview和Embedded Expressions in XML。

对于XML的处理，VB.NET有此锐器，那么IronPython是否有相似的工具呢？Michael搜肠刮肚、翻箱倒柜才找到本属于Python的minidom模块，其中的parseString方法拥有稍微接近的处理能力，但可惜的是，parseString方法返回的对象只能是Document对象，而非ELement，这也意味着parseString并不拥有XML Literal的魔力。

>>> from xml.dom.minidom import parseString
>>> xmlElement = parseString("""
...
...          Some Name
...
...   """)

上述代码在IronPython 2.6中执行，会出现错误。这是因为IronPython对minidom的移植还没有全部完成，缺失了某些模块。具体的workaround如下：
1、下载FePy并且解压至某个目录，譬如D:\FePy；
2、将D:\FePy\Lib\pyexpat.py、 D:\FePy\Lib\xml\dom\expatbuilder.py、D:\FePy\Lib\xml\parsers\expat.py赋值到IronPython相对应的目录中。如第一个文件就复制到D:\IronPython 2.6\Lib的目录下；
3、搜索expatbuilder.py中的NewStyle变量，并且将其删除。

[后记：]一位在Youtube工作的牛人Fredrik Lundh早在2002年就提出了为Python添加XML Literal的功能，~~但是直到现在还没有出现类似的功能，至少Michael现在还没有找到~~。有发现的朋友请告知一声，衷心感谢！

经过limodou兄的指点，Michael找到了xml.etree.ElementTree模块，其中的xml.etree.ElementTree.XML(text)方法在一定程度实现XML Literal特性，毕竟它返回的是Element对象，那么我们就可以基于此进行操作了。xml.etree.ElementTree模块在IronPython 2.6下运行正常。

作者: FantasySoft 发表于 2010-04-24 00:21 原文链接

评论: 2　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

作为.NET程序员，您需要IronPython么？

FantasySoft — Thu, 22 Apr 2010 18:00:00 GMT

.NET作为一个成熟的开发平台，为很多语言的发展提供了肥沃的土壤：历史相对久远的有Managed C++、C#、VB.NET、J#，正值壮年的则有IronPython、IronRuby，而老赵极力推崇的F#则是后起之秀了。面对那么多的语言，选择自然也是一个难题。在大部分开发人员眼中，C#是最为正统的.NET语言，它几乎是为.NET而生的，语言版本更替的速度与.NET Framework相比，一点都不含糊，这不，C# 4.0都出来了。因此，C#通常都是.NET开发人员的首选语言。但是，掌握了C#之后，如果您希望学习多一种语言以增强解决问题的能力；如果您希望了解更多有关编程范式的内容；如果您希望了解DLR甚至编译器的设计；如果您希望……那么，IronPython将会是您的最佳选择，它就像是叮当的万能口袋，只要您伸手，您就会淘到想要的宝贝。

有关IronPython的历史，我在这里就不赘述了。简单的说，它是Python语言在.NET上的实现，既保持了Python所崇尚的编程哲学（想了解它？打开IronPython的控制台，在提示符之后输入import this，出现在屏幕上的就是著名的The Zen of Python），又为.NET开发人员带来了新鲜的开发模式。IronPython与传统的.NET开发语言不同，它是一门解释型的动态语言，也是一门多范式编程语言。尽管解释型、动态与多范式都是非常简单的词汇，但是它能够为开发人员带来更为直接了当的解决方案。譬如，在C# 3.0才引入的Lambda表达式以及闭包（Closure），而IronPython早已极好地支持这些体现了函数式编程的特性。即便是现在，使用IronPython实现闭包、duck typing以及运行期绑定都要比C#和VB.NET来得更为直观。也许您对会“直观”这一点不以为然，而事实上，我们在编写程序的时候，除了要让计算机为我们工作之外，还要让他人能够轻松地阅读我们的代码。作为程序员，我们都知道代码的可读性以及可维护性是多么重要，如果从一个软件的生命周期来看，升级与维护是软件最大的开销。您还记得KISS原则么？是的，就是Keep It Simple & Stupid。IronPython可以帮助我们实现这美妙的“亲吻”，真正去拥抱编程。

除了为开发人员带来更高的生产力之外，IronPython的出现也让“.NET平台糅合各种编程语言”真正实至名归。想必大家都会记得，早在.NET平台诞生之初，它所推崇的多语言协作理念是其最大的噱头。然而，.NET所述的多语言协作性仅仅体现在IL的层面上，那么在实际的项目开发当中，又会有谁愿意同时使用C#和VB.NET进行开发呢？由于IronPython是一门解释型语言，利用它来实现某些不稳定的业务逻辑就再适合不过了，省却了编译的过程，即改即运行。更重要的，我们可以在C#代码当中直接调用IronPython的代码！这些特性都让IronPython完全能够胜任C#左膀右臂的角色。

听Michael罗嗦了那么多，您是否觉得IronPython正是自己的新欢呢？觉得上述文字空洞无物？好吧，最后给大家送上两段代码，Code will tell.

代码一，实现了“把一个字符串数组中的元素转化为整数，再将其中的偶数放入一个List容器中”的功能，C#版的代码可以参考老赵的文章《拯救C# 2.0，但是我们真做的到吗？》：

>>> strArray = ["1", "2", "3", "4"]
>>> intArray = [int(i) for i in strArray if int(i) % 2 == 0]

代码二，实现了“找出长度较短的字符串”的功能，C#版的代码可以参考Klesh.Cn精心翻译的好文：C#和Java的闭包－Jon谈《The Beauty of Closures》中的Example2b.cs 和Example2c.cs：

作者: FantasySoft 发表于 2010-04-23 02:00 原文链接

评论: 24　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

IronPython 承载和消费WCF服务

张善友 — Tue, 26 Jan 2010 12:32:00 GMT

是开始学习IronPython 的时候了文章里谈到了“IronPython 2.6提供了新特性clrtype，允许程序员用纯IronPython代码提供property、attribute等CLR类型信息。这样IronPython代码就可以无缝地与Sliverlight、WCF等框架集成。”我们就用clrtype来看看怎么承载WCF服务和消费WCF服务。WCF的契约需要定义接口，这是目前IronPython 尚未支持的功能，所以我们先用C#定义个一个WCF的契约：

using System;
using System.Collections.Generic;
using System.ServiceModel;

namespace TestServiceInterface
{
///

/// Description of MyClass.
///

    [ServiceContract]
    public interface ImyService
    {
        [OperationContract]
         string GetData(int value);

}

编译成一个程序集TestServiceInterface.dll, 然后在IronPython中实现WCF服务myWcfService.myService，代码如下：

import clr
import clrtype
clr.AddReference('System.ServiceModel')
clr.AddReference('TestServiceInterface')
from TestServiceInterface import ImyService

from System import Console, Uri
from System.ServiceModel import (ServiceHost, BasicHttpBinding, ServiceBehaviorAttribute, InstanceContextMode)

ServiceBehavior = clrtype.attribute(ServiceBehaviorAttribute)

class myService(ImyService):

__metaclass__ = clrtype.ClrClass

_clrnamespace = "myWcfService"

_clrclassattribs = [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]

def GetData(self, value):

return r"IronPython WCF服务: 你的输入内容是: %s" % value

sh = ServiceHost(myService() ,Uri("http://localhost:7000/myWcfService%22 ) )

sh.AddServiceEndpoint(

clr.GetClrType(ImyService),

BasicHttpBinding(),
"")

sh.Open()

Console.WriteLine("Press to terminate\n")
Console.ReadLine()

sh.Close()

这里用到了一个clrtype模块, 代码参加IronPython的Sample工程，可以从这里下载：http://ironpython.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=12482 ，第一个例子就是ClrType ，从这里拷贝出来放到我们的py目录下。类myService 必须加一个attribute InstanceContextMode.Single ServiceBehavior 。

我们再来写个测试的客户端代码：

import clr

clr.AddReference('System.ServiceModel')

from System import Console
import System.ServiceModel

clr.AddReference('TestServiceInterface')

from TestServiceInterface import ImyService

mycf = System.ServiceModel.ChannelFactory[ImyService](

System.ServiceModel.BasicHttpBinding(),

System.ServiceModel.EndpointAddress("http://localhost:7000/myWcfService%22))

wcfcli = mycf.CreateChannel()

print r"IronPython WCF 服务的返回结果是:\n%s" % wcfcli.GetData(11)

Console.WriteLine("Press to terminate\n")
Console.ReadLine()

运行起来可以得到的结果如下：

这样一个基本的WCF服务示例就完成了，示例有个问题是没法使用配置文件来存储WCF的配置信息，只能通过代码方式对WCF服务进行配置。

另外链接几篇IronPython结合Entity Framework的文章，其中也使用到了clrtype模块。

Entity Framework, IronPython and PODO’s – Can it be done? - Part 1

Entity Framework, IronPython and PODO’s – Can it be done? - Part 2

Entity Framework, IronPython and PODO’s – Can it be done? - Part 3

Entity Framework, IronPython and PODO’s – Can it be done? - Part 4

作者: 张善友发表于 2010-01-26 20:32 原文链接

评论: 4　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

是开始学习IronPython 的时候了

张善友 — Tue, 22 Dec 2009 05:09:00 GMT

Dino's Blog 上写一篇文章介绍了IronPython 2.6的Final版本已经发布。IronPython就是优雅的python编程语言和强大的.NET平台的有机结合, IronPython 2.6将完全与CPython 2.6兼容。可以从codeplex下载：http://ironpython.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=12482，下载的安装程序包含了二进制文件、Python标准程序库、用于Silverlight的IronPython和一个教程。此外，还有一个成为Pyc.py的工具，该工具可以把IronPython应用程序编译成二进制文件。Ipy.exe可以用来执行IronPython程序，对于熟悉Python语言及探索.NET程序集来说非常有用。http://ironpython.net/有个用Silverlight开发的Web版本的ipy工具http://ironpython.net/try/ 。

IronPython是流行的程序设计语言Python通向.NET framework的一个端口。微软公司对于.NET framework的IronPython和动态语言非常关注。微软公司已经在各种项目中提供了对IronPython的支持。

IronPython已经很好的集成到了.NET framework中，Python语言中的字符串对应于.NET的字符串对象，并且Python语言中对应的方法，在IronPython中也都提供了。其它数据类型也是一样。

MSDN Channel9发布了一段非常精彩的演讲，其内容是IronPython团队的Harry Pierson评论.NET平台上动态语言的发展。

Jim Hugunin是IronPython（也是Jython）的创造者。在构造IronPython的过程中，他发现CLR（Common Language Runtime）对动态语言提供了很好的支持，同时也发现了一些技术问题。为此，他和CLR团队进行了深入的交流。最终，他决定加入微软，加入CLR团队，拟也许注意到Jim Hugunin并不是IronPython得开发者了，而是在构造更适合动态语言的CLR。他们的工作成果之一就是DLR（Dynamic Language Runtime）。

DLR构建在CLR之上，提供了一批服务和API，使得语言开发者能够容易地构造编程语言。它不但是IronPython 2.x的基础，也是C# 4.0的基础。C# 4.0提供了dynamic关键字，可以实现运行时的结构一致性语义（即duck typing）。从语句表达，到底层实现，C#已经完全动态化，动态语义已经渗入其机理。可见，DLR不但打通了IronPython与C#交互的关键，也必将影响到.NET平台上的所有开发者。

IronPython与DLR是共生关系：CLR团队用IronPython来驱动DLR的开发，DLR的开发成果又反过来支持IronPython的进一步演化。这也表明，IronPython将受到微软的持续支持。也许有人会问：既然C# 4.0已经动态化，那么为什么还需要掌握一种“真正”的动态语言呢？Harry Pierson的回答是：用合适的工具做事（choose the right tool for the job）。Harry曾经是C#最早一批的开发者和使用者，现在是IronPython团队的程序经理。与《IronPython in Action》的作者Michael Foord相似，他很擅长也很喜欢C#，同时也非常热爱IronPython。

抱定一种统一语言不放的年代就快结束了，我们正在进入一个专业细分的新时代，函数式语言更擅长并发（F#已经集成到Visual Studio 2010），动态语言更擅长表达领域模型和业务逻辑。将这些语言都聚合在一个统一的平台上（.NET或Java），将为开发者提供更丰富的工具箱：“一方面选择使用针对当前工作的最佳工具，另一方面发挥底层平台的健壮性与资源丰富的优势”。

如《Learning Python》所言：“无论是短期策略任务（测试或系统管理），还是长期战略上的产品开发，Python已经被证明它是无所不能的”。而Python 2.6的一致性、简洁性、兼容性也受到广泛认同。因此，IronPython 2.6的语言成熟度很高，能够用简洁的代码表达丰富的语义。

IronPython 2.6，它为程序员提供了什么优势呢？

首先，它的语法与Python 2.6兼容。第二，IronPython 2.6在动态语言与CLR集成上有重大突破。IronPython 2.6提供了新特性clrtype，允许程序员用纯IronPython代码提供property、attribute等CLR类型信息。这样IronPython代码就可以无缝地与Sliverlight、WCF等框架集成。相关技术细节可以参考Harry的系列文章。第三、开发环境对于语言的成功也至关重要，Visual Studio集成是必不可少的。Harry在他的Blog中提到，在IronPython 2.6正式版发布后，他们会考虑Visual Studio Integration和IronPython 3.x。从Harry的演讲可知，IronPython不会进入Visual Studio 2010 RTM（2010年3月以后，微软刚刚宣布了推迟发布Visual Studio 2010 RTM），Visual Studio 2010 SDK会携带一个IronPython 2.6集成的例子。

PDC2009相关Session：

Using Dynamic Languages to Build Scriptable Applications

Dynamic Binding in C# 4

作者: 张善友发表于 2009-12-22 13:09 原文链接

评论: 4　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

Python:FriendFeed的Tornado Web Server

张善友 — Fri, 11 Sep 2009 23:05:00 GMT

代码很简单，不到5k行。但是思路挺好的，改成non-blocking了之后效率就是能提高不少，特别是考虑到现代的web app都需要和其他的HTTP服务器通信，blocking的代价太大了。

Tornado is an open source version of the scalable, non-blocking web server and tools that power FriendFeed. The FriendFeed application is written using a web framework that looks a bit like web.py or Google's webapp, but with additional tools and optimizations to take advantage of the underlying non-blocking infrastructure.
The framework is distinct from most mainstream web server frameworks (and certainly most Python frameworks) because it is non-blocking and reasonably fast. Because it is non-blocking and uses epoll, it can handle thousands of simultaneous standing connections, which means it is ideal for real-time web services. We built the web server specifically to handle FriendFeed's real-time features — every active user of FriendFeed maintains an open connection to the FriendFeed servers. (For more information on scaling servers to support thousands of clients, see The C10K problem.)
See the Tornado documentation for a detailed walkthrough of the framework.

Tornado: Facebook Releases Python Framework as Open Source

http://www.linux-magazine.com/Online/News/Tornado-Facebook-Releases-Python-Framework-as-Open-Source

作者: 张善友发表于 2009-09-12 07:05 原文链接

评论: 2　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

Gestalt - 在浏览器里用 python/ruby 写客户端脚本

木野狐(Neil Chen) — Fri, 24 Jul 2009 03:41:00 GMT

作者: 木野狐(Neil Chen) 发表于 2009-07-24 11:41 原文链接

评论: 2　查看评论　发表评论

网站导航：博客园首页我的园子新闻闪存博问知识库

Visual Studio 2010 Beta 1探索笔记（2）：动态特性与IronPython

redmoon — Thu, 21 May 2009 04:44:00 GMT

在.NET 4.0中加入的一个重要特性就是动态特性，即所谓的dynamic关键字。更多的信息可以参看MSDN的帮助，或阅读如下InfoQ文章：

《微软.NET编程语言的未来》，《.NET和动态语言》。

微软今早发布了2.6 CTP for .NET 4.0 Beta 1，要完成在.NET 4.0中调用IronPython的工作，需要如下步骤：

安装Visual Studio 2010 Beta 1
从http://ironpython.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=27320安装IronPython.msi
跟随这个博客文章，进行操作：http://blogs.msdn.com/vbteam/archive/2008/12/17/walkthrough-dynamic-programming-in-visual-basic-10-0-and-c-4-0-lisa-feigenbaum.aspx

下面是我的一些探索体会：

搭建环境还比较麻烦，要从2.6 CTP for .NET 4.0 Beta 1的安装目录中添加IronPython.dll, IronPython.Modules.dll, and Microsoft.Scripting.dll程序集。理论上Microsoft.Scripting.dll作为DLR的主程序集应该直接包含到.NET 4.0中，目前似乎还是分开的。
另外由于py文件要调用一些Python模块，所以还必须把2.6 CTP for .NET 4.0 Beta 1的安装目录中的Lib目录Copy到Debug中
在Debug Run模式下，似乎无法载入py文件，也不出错，就一直停在那里，在Run without debug和直接运行的时候，就能正常运行。这应该是一个Bug，大家要注意。
dynamic可以代替var关键字使用，当然这样的话，变量就无法被推导，也就没有智能提示。

下一篇，我打算体验一下动态特性和Silverlight的交互，敬请期待！

本笔记的源代码如下(不要用迅雷等下载)：http://cid-f73516baeac50992.skydrive.live.com/self.aspx/SharedCode/IronPython%7C_Dynamic.zip

作者: redmoon 发表于 2009-05-21 12:44 原文链接

评论: 6　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

使用IronPython检测ASP.NET程序状况（下）

Jeffrey Zhao — Wed, 25 Mar 2009 01:03:00 GMT

在上一篇文章中，我们在一个请求中执行了IronPython代码，通过这个方法我们可以轻松地的检查系统运行的状态，或对系统进行一些简单修改。但是这种做法只能检查系统在当前时刻的状态，在很多情况下，我们需要对系统的请求进行一段时间的采样。对于简单的数据（例如每秒执行的请求数量，请求时间），我们可以通过查看Performance Monitor中相关的计数器来获得一些概要的数据。但是，如果我们需要获取一些系统的详细状态，甚至是需要根据需要进行动态改变的自定义需求，则势必要深入到系统内部进行数据采集。因此，我们可能需要让代码执行“一段时间”，并将直接结果进行汇总输出。

让代码执行一段时间不难，简单地使用Thread.Sleep便可，也不会造成什么性能或吞吐量上的损失。关键就在于，在代码停留的这“一段时间”内，我们使用什么样的做法来采集数据。这时候，老赵脑海中立即浮现出的便是HttpModule般监听请求管道（Pipeline）中的各式事件。于是立马写出以下的代码（在前文的示例基础上进行修改）：

protected void btnExecute_Click(object sender, EventArgs e)
{
    ScriptEngine engine = Python.CreateEngine();
    var scope = engine.CreateScope();
    var script = engine.CreateScriptSourceFromString(
        this.txtCode.Text, SourceCodeKind.Statements);
    script.Execute(scope);

    TextWriter writer = new StringWriter();
    scope.SetVariable("logger", writer);

    Action<HttpContext> traceRequest;
    if (scope.TryGetVariable<Action<HttpContext>>("traceRequest", out traceRequest))
    {
        Action endTraceRequests;
        scope.TryGetVariable<Action>("endTraceRequests", out endTraceRequests);

        int waitTime;
        if (!scope.TryGetVariable<int>("waitTime", out waitTime))
        {
            waitTime = 10000;
        }

        this.TraceRequests(traceRequest, waitTime, endTraceRequests);
    }

    this.txtOutput.Text = writer.ToString();
}

private void TraceRequests(Action<HttpContext> traceRequest, int waitTime, Action endTraceRequests)
{
    EventHandler handler = (sender, e) =>
    {
        try
        {
            traceRequest((sender as HttpApplication).Context);
        }
        catch { }
    };

    this.Context.ApplicationInstance.BeginRequest += handler;
    Thread.Sleep(waitTime);
    this.Context.ApplicationInstance.BeginRequest -= handler;

    if (endTraceRequests != null) endTraceRequests();
}

再编译了IronPython代码之后，我们会设法获取其中的traceRequest和endTraceRequests函数，前者用于“记录每个请求”，而后者用于采样最后的“聚合”。此外，还会设法从代码中获取等待时间waitTime。然后，使用TraceRequest方法开始对当前请求进行采样。具体做法为监听当前Application的BeginRequest事件，并在每次获得请求时调用traceRequest委托进行“记录”。在等待时间过后，自然将委托从BeginRequest事件中剥离。最后，再通过endTraceRequests函数进行聚合输出。

代码逻辑很清晰，但可惜的是，上面这段代码不能生效。具体原因不明，可能是ASP.NET对这方面进行了限制，使得我们无法在HttpModule之外为请求管道动态添加事件处理函数（存疑，求证）。对此我们只能进行让步。不过，既然ASP.NET允许HttpModule监听管道事件，那么我们不如事先准备一个HttpModule监听各种事件，并且在合适的时候把这一事件转发给IronPython函数。我们这里还是以BeginRequest事件为例：

public class IronPythonTraceModule : IHttpModule
{
    private class TraceRequestEventArgs : EventArgs
    {
        public TraceRequestEventArgs(HttpContext context)
        {
            this.HttpContext = context;
        }

        public HttpContext HttpContext { get; private set; }
    }

    public void Dispose() { }

    public void Init(HttpApplication context)
    {
        context.BeginRequest += new EventHandler(OnBeginRequest);
    }

    static void OnBeginRequest(object sender, EventArgs e)
    {
        var traceRequest = IronPythonTraceModule.TraceRequest;
        if (traceRequest != null)
        {
            var context = (sender as HttpApplication).Context;
            traceRequest(null, new TraceRequestEventArgs(context));
        }
    }

    private static event EventHandler<TraceRequestEventArgs> TraceRequest;

    public static void TraceRequests(
        Action<HttpContext> traceRequest,
        Action endTraceRequests,
        int milliseconds)
    {
        EventHandler<TraceRequestEventArgs> handler = (sender, e) =>
        {
            try
            {
                traceRequest(e.HttpContext);
            }
            catch { }
        };

        IronPythonTraceModule.TraceRequest += handler;
        Thread.Sleep(milliseconds);
        IronPythonTraceModule.TraceRequest -= handler;

        if (endTraceRequests != null) endTraceRequests();
    }
}

IronPythonTraceModule需要放入应用程序中，它时刻对请求管道的BeginRequest进行监听，只是在合适的时候才会发起TraceRequest静态事件（显然这并不会对系统性能造成什么影响）。Module包函一个静态的TraceRequests方法，这便是给外部调用的接口。可以发现这段代码和之前的TraceRequests方法非常接近，唯一不同的只是动态添加/删除处理函数的事件是IronPythonTraceModule.TraceRequest，而不是HttpApplication.BeginRequest。于是，原来的代码也需要做一定修改：

protected void btnExecute_Click(object sender, EventArgs e)
{
    ...

    Action<HttpContext> traceRequest;
    if (scope.TryGetVariable<Action<HttpContext>>("traceRequest", out traceRequest))
    {
        Action endTraceRequests;
        scope.TryGetVariable<Action>("endTraceRequests", out endTraceRequests);

        int waitTime;
        if (!scope.TryGetVariable<int>("waitTime", out waitTime))
        {
            waitTime = 10000;
        }

        // 以下代码有所修改
        IronPythonTraceModule.TraceRequests(traceRequest, endTraceRequests, waitTime);
    }

    this.txtOutput.Text = writer.ToString();
}

现在我们进行一番测试，简单地检测一下5秒钟内收到了多少请求：

使用自己的Module进行处理还有其他一些好处，比如可以提供更好的控制。事实上，目前文章里的解决方案有一些缺陷，并且肯定无法完全满足真实需求。不过我们完全可以对目前的做法进行改进，例如：

保证代码执行的线程安全，包括事件添加时和traceRequest函数执行时。
提供“采样特性”，而不是对每个请求都使用traceRequest函数进行处理。
将Logger放入公用的空间，并在程序代码中植入检查功能，这样便可以得知当前系统中每个功能的执行时间（这就是Profiler的功能，不是吗？）。

不过，除了应对前一篇文章中所提到的负载均衡环境下的问题之外，这个解决方案还有另一个较为重要的情况需要特殊对待。如果使用目前的做法，每次采样都是通过一个请求进行的，所以它并不会在在请求队列阻塞时立即执行，但是采样的常见场景便是在队列阻塞时间检查状况，这显然形成了一个矛盾。不过要解决这个问题并非难事，只要采样不要通过IIS即可。例如您使用普通Socket，或“偷偷懒”使用WCF的TcpBinding进行采样便可——只要和被检查的应用程序在同一进程（即w3wp.exe，还有人用IIS5 吗？）中，便可以使用任何方式进行通信。

改变、探索的过程，其实都是在追求一种编程的美感。老赵喜欢“不拘一格”，只要是有价值的都会去设法尝试一番，探索的过程会遇到大量问题，解决问题后又能带来成就感以及新的感受。因为美感和成就感，所以产生乐趣，因为乐趣才有源源不断地动力。因为有这样的切身体会，所以在这里也建议大家，不妨放开思路，海纳百川。我们可以获得和想到的东西，远比预料中来的丰富。

相关文章：使用IronPython检测ASP.NET程序状况（上）

作者: Jeffrey Zhao 发表于 2009-03-25 09:03 原文链接

评论: 21　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

Ironclad

张善友 — Wed, 18 Feb 2009 14:26:00 GMT

Ironclad是一个开源项目,目的是使得IronPython可以使用CPython C Extensions。虽然IronPython可以使用大部分的Python库。这个库是由Resolver Systems开发的，使用MIT License协议。

项目地址：http://code.google.com/p/ironclad/

作者: 张善友发表于 2009-02-18 22:26 原文链接

评论: 0　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

IronPython 2.0 发布了

张善友 — Mon, 15 Dec 2008 05:19:00 GMT

DLR团队终于发布了 IronPython 2.0 ，IronPython 2.0完全基于Dynamic Language Runtime (DLR). DLR允许多个动态语言在系统类型层面实现互操作。这个版本修复大概500多个bug，有453个来自codeplex社区的反馈。热烈祝贺开发团队发布了这一个重大的里程碑版本。可以到codeplex上去下载，下面是一些重要的链接：

项目codeplex站点http://www.codeplex.com/IronPython
下载地址 http://www.codeplex.com/IronPython/Release/ProjectReleases.aspx?ReleaseId=8365
发布说明：http://www.codeplex.com/IronPython/Wiki/View.aspx?title=v2.0.0%20Release%20Notes&referringTitle=Home
IronPython Cookbook: http://www.ironpython.info/index.php/Main_Page

下面是IronPython 2.0一些说明：

要求安装.NET 2.0 SP1
和CPython 2.5 兼容，有几个不同的地方，参看Differences between IronPython 2.0.x and CPython 2.5.2
性能良好: 比Python 2.5 快1.8 倍，使用 PyStone 基准测试的
可以调用大部分的标准 Python 库和所有.NET 库

Example IronPython code. Including Silverlight and embedding IronPython and C#.

http://code.google.com/p/ironpython/

作者: 张善友发表于 2008-12-15 13:19 原文链接

评论: 0　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

动态语言运行时(DLR)官网

张善友 — Sun, 02 Nov 2008 12:34:00 GMT

目前，DLR的源代码只能从IronPython、IronRuby或者Silverlight Dynamic Languages SDK获得。从11月份开始，DLR将拥有自己的CodePlex站点。这个站点将提供IronPython、IronRuby和DLR的源码和文档的一站式服务。计划在11月内发布DLR v0.9，在IronPython 2.0的时候正式发布。动态语言运行时(DLR)官网地址：Dynamic Language Runtime

作者: 张善友发表于 2008-11-02 20:34 原文链接

评论: 0　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

[集成IronPython] 使CLR对象对动态语言更友好（三）—— 使用ExtensionTypeAttribute

Colin Han — Mon, 06 Oct 2008 02:08:00 GMT

动态类型语言（以下简称："动态语言"），在10年前就已流行起来。JavaScript更是成为了WEB前台开发的事实标准。但它们进入普通开发人员的视野也就在近几年。随着Web2.0和敏捷开发方法论的兴起，动态语言的灵活高效的特性成为了它被更多项目选择和使用的理由。一些大型网站已开始使用动态语言来实现，其中，国内比较优秀的作品有“豆瓣”。微软更是不甘落后，建立了DLR（动态语言运行时）来吸引动态语言爱好者在其上实现动态语言。IronPython就是其主要成员之一。

在本系列文章中，我们将逐步实现一个自定义控件，实现类似IDE的Immediate窗口的功能。用户可以在其中输入和运行IronPython代码。【返回目录】

在前面的两节中，我们在一个普通对象和一个Collection上实现了几个SpecialName方法。从而使得我们的业务对象能够支持一些动态语言的特性。比如：支持动态添加删除属性和支持切片。但是：

有些时候，我们不希望在非动态语言环境中看到这些对象。
有些时候，我们不希望我们的业务对象依赖于Microsoft.Script.dll这个奇怪的Assembly
有些时候，我们可能根据我们的业务需要，让一个系统对象（比如：System.Collections.Generic.Dictionary)能够能够支持一些特别的操作。
有些时候，我们的用户就是很变态（也许你还有一些变态的要求，不防在留言中提出。我们一起讨论，看有没有合适的解）

我们先来看一个微软的例子

Asp.NET Futures是微软新近发布的一个组件包，其中包含了ASP.NET对DLR的支持部分。基于这个组件包，你可以使用IronPython或Managed JScript开发ASP.NET应用。

Python语言秉承的信条是“简洁的优于复杂的// TODO:”，因此，为了简化开发人员的工作，ASP.NET Futures中也包含了一些DLR友好的对象。比如下面的两段代码。

// C# Code
string myValue = Request.QueryString["MyValue"];

和

# Python Code
myVar = Request.MyValue

很显然，Python代码比起C#代码简单了不少。（如果你实际使用一下IronPython，你会发现Python语言确实使得代码更加精炼，开发更加快速，只是我现在还不确定，调试的难度有多高）。

其实，上面的功能实现起来很简单。只需要在HttpRequest类型上添加两个方法就可以实现。如下：

1namespace System.Web.UI
2{
3  public class HttpRequest
4  {
5    // 其它实现逻辑
6    [SpecialName]
7    public IList<SymbolId> GetMemberNames()
8    {
9      return this.Params.AllKeys;
10    }
11    [SpecialName]
12    public object GetBoundMember(string name)
13    {
14      return this.Params[name];
15    }
16  }
17}

注：上面的代码仅为了表达意思，其中有明显的语法错误，实际的代码要比上面的稍微复杂一点。

上面的代码中，GetMemberNames方法告诉DLR系统通过这个方法获得该对象上的所有属性（你可以认为方法是一个Delegate类型属性）而不是通过反射。下面的GetBoundMember方法实现具体的Get属性或方法实现。通过SpecialNameAttribute以标识这些方法可以被DLR使用。

但是，上面的实现使得HttpRequest对象多出了两个公共接口。对于没有深入理解过DLR的实现的开发人员来说，这两个接口非常的费解。怎样让C#开发人员和IronPython语言开发人员都很舒服呢？

我们来看看微软的实现

首先，微软在ASP.NET Future中关于动态语言支持的代码主要在Microsoft.Web.Scripting.dll中。因此我们从这个Assembly开始着手。使用Reflector打开这个文件，我们可以看到Assembly中添加了这个Attribute。

[assembly: ExtensionType(typeof(HttpRequest), typeof(RequestParamsMembersInjector))]

注：注意，这个Attribute是添加在Assembly上，而不是扩展的任何一方的类型上。因为加载一个Assembly时遍历其中的类型是一件低性能并危险的事情。

呵呵，从标题中，大家应该已经知道“ExtensionTypeAttribute”是本节内容的重点。就是他实现了为已有CLR对象添加DLR支持功能的。

我们顺藤摸瓜，找到RequestParamsMembersInjector这个类型的实现，如下：

1 public static class RequestParamsMembersInjector
2 {
3     // Methods
4     [OperatorMethod] // 注1
5     public static object GetBoundMember(HttpRequest request, string name)
6     {
7         return request.Params[name];
8     }
9 }

注1：这里也许是以前版本的定义。在Bata3中没有找到这个Attribute，取而代之的是SpecialNameAttribute。

通过这个类，实现了为HttpRequest类型添加了一个GetBoundMember方法。看起来很像.NET 3.5提供的扩展方法。只是this关键字被SpecialNameAttribute代替了。

最后，给出一个我们自己的实现

这一节，我们为DLConsole添加了一个LoadAssembly方法，用来加载Extension。我们在测试工程中添加了一个SimplaXmlExtension类型实现访问XmlElement的子节点的功能。你可以从这里下载可运行的源代码。扩展的代码如下：

扩展的实现代码
1[assembly: ExtensionType(typeof(XmlElement), typeof(TestDynamicLanguageConsole.SimpleXmlExtension))]
2
3namespace TestDynamicLanguageConsole
4{
5    public static class SimpleXmlExtension
6    {
7        [SpecialName]
8        public static IList<SymbolId> GetMemberNames(object obj)
9        {
10            List<SymbolId> list = new List<SymbolId>();
11            XmlElement xml = obj as XmlElement;
12
13            if (xml != null)
14            {
15                for (XmlNode n = xml.FirstChild; n != null; n = n.NextSibling)
16                {
17                    if (n is XmlElement)
18                    {
19                        list.Add(SymbolTable.StringToId(n.Name));
20                    }
21                }
22            }
23
24            return list;
25        }
26
27        [SpecialName]
28        public static object GetBoundMember(object obj, string name)
29        {
30            XmlElement xml = obj as XmlElement;
31
32            if (xml != null)
33            {
34                for (XmlNode n = xml.FirstChild; n != null; n = n.NextSibling)
35                {
36                    if (n is XmlElement && string.CompareOrdinal(n.Name, name) == 0)
37                    {
38                        if (n.HasChildNodes && n.FirstChild == n.LastChild && n.FirstChild is XmlText)
39                        {
40                            return n.InnerText;
41                        }
42                        else
43                        {
44                            return n;
45                        }
46
47                    }
48                }
49            }
50
51            throw new ArgumentException();
52        }
53    }
54}
55

你可以在程序中输入并运行如下的Python代码来测试这个扩展的工作。

print Foo.bar1
print Foo.bar2

总结

在前几篇文章的留言中，RednaxelaFX提到真正的让一个CLR对象支持动态语言，还是需要实现IDynamicObject接口。下去研究了一下，这个接口确实提供了更加强大的能力。如下：

namespace Microsoft.Scripting.Runtime {
    public interface IDynamicObject {
        RuleBuilder<T> GetRule<T>(DynamicAction action, CodeContext context, object[] args) where T : class;
    }
}

如此简单的接口，可见其功能强大吧。领会这个接口还需要对DLR有更深入的了解。下面的这个系列的文章可以帮助你更好的理解DLR的一些实现机理。但是，如果你如我一般对编译原理一窍不通。深入这一层次确实是一件危险的事情。

LINQ与DLR的Expression tree（1）：简介LINQ与Expression tree
LINQ与DLR的Expression tree（2）：简介DLR
LINQ与DLR的Expression tree（3）：LINQ与DLR及另外两个库的AST对比
 LINQ与DLR的Expression tree（4）：创建静态类型的LINQ表达式树节点
 LINQ与DLR的Expression tree（5）：用lambda表达式表示常见控制结构

相信我们本节提到的方法，就是微软为了减少我们这些菜鸟的学习成本而提出的一个快速解决方案。基本上，我们平时能够想到的大多数功能都可以通过这个扩展注入到原有对象上了。

但是，这里还有一个小问题需要注意：

如果扩展对象和被扩展对象不再同一个Assembly中，你必须先将扩展所在的Assembly加载进来（使用ScripDomainManager.LoadAssembly方法(c#)或clr.AddReference方法（Py）），然后操作被扩展对象才能够使用扩展所添加的功能。因为，DLR使用的是JIT的技术，也就是说他在第一次操作一个类型的对象时，会将对这个对象的操作Cache下来。下一次他就会直接使用Cache下来的操作。而不是每一次都解释执行代码。

至此，我们基本可以完成大多数我们期望的动态语言友好性扩展（关于具体都可以编写哪些SpecialName方法，我会专门编写一章来讨论）。DLConsole也基本完成了。在下一节，我们将考虑让DLConsole支持其他的动态语言。每周一节，敬请关注

大家可以从这里下载可运行的源代码。

免责声明：本系列文章，完全是我个人研读 IronPython源代码后找到的实现方案，并未详细的研究过IronPython的相关官方文档。因此，并不保证符合微软DLR和IronPython的设计思路，亦不能保证在DLR和IronPython 2.0正式发布后能够继续使用。

作者: Colin Han 发表于 2008-10-06 10:08 原文链接

评论: 9　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

IronPython 2.0 beta 5

张善友 — Mon, 29 Sep 2008 07:50:00 GMT

ironpython 2.0 beta 5 已经发布，下载地址：http://www.codeplex.com/IronPython/Release/ProjectReleases.aspx?ReleaseId=15625。IronPython 2.0 Beta 5是2.0系列的最后一个beta版本，下个版本就是RC版了。也就是说到了下个版本所有API都将固化了。现在也是到学习IronPython 2的时间了。从beta 4发布就有了msi 安装文件,并且带来了python的标准库 ,标准库的许可是以Python Software Foundation license 发布，这也就意味着移值cpython应用会很容易了。

值得注意的是带来了DLR hosting spec 的稳定版本，你可以从这里下载 DLR hosting spec的word 版本 http://compilerlab.members.winisp.net/dlr-spec-hosting.doc

这个版本还有一个最明显的变化的是命名空间作了个重大的修改，把所有的DLR 类型从System移到了Microsoft，原因是http://lists.ironpython.com/pipermail/users-ironpython.com/2008-August/thread.html#8036 许多人把IronPython嵌入到C# （.NET 3.5）项目中。

另外一点是DLR 宿主API不有一个针对Python的默认配置，现在应该用IronPython.Hosting.Python去创建脚本引擎，这样在应用程序中宿主IronPython就更容易了。IronPython.Hosting.Python有几个辅助方法，以创建一个ScriptRuntime或ScriptEngine ，并为ScriptRuntime和ScriptEngine增加了一些Python-specific 扩展方法。

using IronPython.Hosting;

ScriptEngine engine = Python.CreateEngine();

ScriptScope sys = engine.GetSysModule();
var platform = sys.GetVariable("platform");
Console.WriteLine(platform);

ScriptScope builtins = engine.GetBuiltinModule();
var pow = builtins.GetVariable>("pow");
Console.WriteLine(pow(2,3));

ScriptScope clr = engine.GetClrModule();
var getPythonType = clr.GetVariable>("GetPythonType");
Console.WriteLine(PythonType.Get__name__(getPythonType(typeof(string))));

引用：http://blogs.msdn.com/srivatsn/archive/2008/09/16/hosting-ironpython-made-easier.aspx

如何在托管语言中调用动态语言。

首先，我们需要初始化动态语言的环境配置，从中获取所有可以使用的动态语言列表，然后得到相应动态语言的运行引擎。

ScriptRuntimeSetup setup = new ScriptRuntimeSetup(true); //true表示载入所有支持的动态语言的环境配置
ScriptRuntime runtime = ScriptRuntime.Create(setup); //创建动态语言运行环境

foreach (LanguageProviderSetup langSetup in setup.LanguageProviders) //遍历所有动态语言的环境配置
{
    try
    {
        ScriptEngine engine = null;
        if (runtime.TryGetEngine(langSetup.Names[0], out engine)) //尝试获取动态语言的运行引擎
        {
            //engine就是我们需要的运行引擎
        }
    }
    catch (MissingTypeException) //处理创建不支持的动态语言时可能抛出异常
    {
    }
}

获取了运行引擎后，我们就可以执行动态语言的代码了

public class MyErrorSink : ErrorSink //编译错误处理
{
    IList<string> m_ErrorMsg = new List<string>();
    public IList<string> ErrorMsg
    {
        get { return m_ErrorMsg; }
    }

    public MyErrorSink()
    {
    }
    public virtual void Add(SourceUnit source, string message, SourceSpan span, int errorCode, Severity severity)
    {
        if (severity == Severity.Error || severity == Severity.FatalError)
        {
            m_ErrorMsg.Add(message);
        }
    }
}

LanguageContext langContext = HostingHelpers.GetLanguageContext(engine);
SourceUnit sourceUnit = langContext.CreateSourceUnit(new SourceStringContentProvider("1/4+3"), null, SourceCodeKind.Expression); //创建代码序列：1/4+3

MyErrorSink errorSink = new MyErrorSink();
try
{
    Scope scope = new Scope();
    object ret = sourceUnit.Execute(scope, errorSink); //执行动态语言代码，ret就是执行结果的返回值了

    if (errorSink.ErrorMsg.Count > 0) //检查编译错误
    {
        //
    }
}
catch (Exception)
{
}

引用: http://blogs.msdn.com/silverlightshanghai/archive/2008/09/18/dlr-in-silverlight.aspx

作者: 张善友发表于 2008-09-29 15:50 原文链接

评论: 2　查看评论　发表评论

编辑推荐：Ruby之父松本行弘的编程人生

网站导航：博客园首页我的园子新闻闪存博问知识库

IronPython for ASP.NET 的支持更新了

木野狐(Neil Chen) — Wed, 24 Sep 2008 09:40:00 GMT

作者: 木野狐(Neil Chen) 发表于 2008-09-24 17:40 原文链接

评论: 3　查看评论　发表评论

网站导航：博客园首页我的园子新闻闪存博问知识库