博客园_夏狼哉的博客

解释器漫谈

2012-03-19T16:18:00Z

最近连续做了三个语言解析器，一个是SQL的，另外两个是我自己设计的语法格式，我分别把它们叫做XGML和GORL。

XGML是继承自XML的一种语法格式。本来我是希望直接使用.Net自带的XML读写类的，但是发现XML对符号的限制实在太多，我需要大量地在元素名、属性名、值中写入语法符号（如尖括号，方括号，大括号等），经过一番试验，发现直接使用XML完全没有可能，于是我决定自己动手来实现一个XML的读写类。

既然自己实现了XML的读写器，我后来觉得干脆进一步扩展其功能，比如我允许每个元素定义自己的特性（Attribute），并且为每种结构定义了语法含义，而且在语法形式上也有所修改，最重要的是它们能够直接映射成为C#对象，这样一来，它就形成了一种类似但不同于XML的新的东西，我于是称其为XGML。

在XGML的设计之初，为了方便起见，我为其定义了两种语法形式，一种是基于XML格式的主体语法，另一种是类似于JSON的嵌入式语法，用于辅助XGML的对象映射功能，这种嵌入式语法我称其为InlineXGML。但是在试用了一段时间以后，我发现短小精悍的InlineXGML在使用过程中要远远比冗长的XGML来得方便，我开始认真考虑用InlineXGML完全替代XGML的可能性。

经过一番考量，我觉得这完全是可行的，于是我重新设计了InlineXGML的语法规范，使其在功能上能够完全替代XGML，而且还包括一些XGML无法实现的功能，例如我非常喜欢的默认属性、集合构造器等，这样一来，再称其为InlineXGML显然是不合时宜了，于是我为它起了个新的名字，叫做Goodbaby Object Rendering Language（GORL)。

GORL的设计目的非常明确，就是呈现一个对象，这与XGML有所不同，XGML虽然也能够呈现对象，但是由于XML本质上的松散结构，XGML实际上还包含许多非对象呈现的因素，这也导致它很难进一步为对象呈现作优化。而GORL则完全是用于呈现一个对象，虽然它继承了一部分XML的概念，但是完全不受XML的束缚。

例如，定义一个C#类型Apple，它有一个string型的属性Name，Dictionary<int,string>型的属性Standard，用GORL表示为：
{Apple Name=apple1 Standard=[(1,'good morning'),(2,hello)]}
或者可以把Name设定为默认属性，这样去定义另一个对象：
{Apple apple2} ，

如果只想表示一个值类型的数组（这种需求一般不存在）：

{int[]=[3,4,5]},

可以为类或属性定义特性：

{[MyAttribute]Apple apple3}

对于XGML或GORL来说，解析其语法只是实现了第一步，第二步是执行部分，需要把上述GORL代码转换成一个C#对象，在实现机制上，GORL的性能是非常好的，首先我将所有的值类型、以及常用类型、用户自定义类型都加入字典，当分析一个类型的时候，首先去查字典，一般来说，99%以上的概率会在字典中命中，如果是罕见类型，未能在字典中查到，则搜索当前程序集，然后是mscorlib，再然后其它程序集，一旦在任何一个程序集中找到类型，则将此类型加入字典，所以无论什么类型，连续使用时，GORL解释器的返回性能都是极高的。

在对象值的解析上，我为常见类型进行了单独的优化设计，所以绝大多数情况下，使用GORL序列化/反序列化的性能要远远高于其它任何一种类似技术。

这样说我是有依据的。在实现GORL之前，我曾经犹豫过很长一段时间是否考虑使用JSON，虽然使用JSON会受到各种约束，但是毕竟会比较省事，这期间我看了JSON在.net中的实现代码，真的是非常复杂，后来考虑到GORL也可以把JSON集成进来作为GORL的一部分功能，我决定不能把自己绑在JSON上，使自己以后处处被动，还是要实现GORL。经过一天半的努力，在今天凌晨0点之前，终于完成了GORL的绝大部分设计功能，还有一小部分功能暂时用不上，以后有心情再做，而总代码只有不足1300行！

当然GORL的顺利实现是建立在SQL解析器的基础上的。

语法解析部分应该说是编译中最复杂的部分，在做SQL解析器多年之前，我已经实现过一个简单的批处理解释器，自觉对解析源代码还是比较有经验的，加之我一向对自己处理复杂程序的能力信心十足，所以我一开始打算一遍完成语法分析。

“遍”是编译原理中很基本的一个概念，在正统的流程中，解析一种语言会经过很多遍代码扫描，但是如果能够在一遍中完成词法和语法的解析，效率显然会更高一些。由于SQL是一种相对来说比较简单的语言，所以我觉得一遍完成是可能的。

但是，事实是很残酷的，在我经过两天焦头烂额的编程之后，我决定在自己吐血之前放弃这个想法。SQL虽然比较简单，但是它太灵活多变了，子查询和表达式的任意嵌套让我一度怀疑自己是否真的有可能写出这个解析器。经历了一次失败以后，我端正了心态，不能幻想着一遍实现这种有点荒唐的想法，必须严格按流程来，先实现词法分析器，生成中间表，再去分层、逐步实现语法分析。

新的程序很快就出来了，我只用了一天就完成了词法分析器，当我在词法分析器工作的基础上进行语法分析时，那叫一个安逸！回想起此前一踏糊涂的工作场景，此刻我才真正体会到了前人的智慧是不容随意挑战的，“大跃进”是不能随便搞的…… 建立在词法分析基础上的语法分析流程非常清晰，虽然编程量不小，但是写程序的过程中还是很轻松的，完全不需要绞尽脑汁地应对千头万绪的上下文以至于整个程序有失控的风险。全部工作完成用了一周半的时间。

至此，我觉得实现一个真正的编译器也完全有思路了。相对于语法极为松散的sql，我觉得实现一个C语言的解析器说不定会更加轻松一些。至于解析以后的生成目标代码部分，事实上，根据对象结构生成某种代码是非常容易的，较为复杂的是如何进行代码优化，如果不考虑优化这回事，只要生成相应的汇编就算是一个编译器了。

有了SQL的基础，再去解析XGML或GORL就变得非常简单了，虽然在实现GORL之前我一度犹豫过，但是现在我已经非常庆幸自己当时没有去偷这个懒，GORL的解析/执行都是如此简洁，它的性能和扩展性都远非JSON可比，更何况它还像XGML一样支持特性？

本文链接

C#与Outlook交互收发邮件

2012-03-11T14:15:00Z

.Net对POP3邮件系统已经集成了相应的功能，但是如果是基于Exchange server的邮件系统，相对就比较复杂。如果仅仅是发送，可以简单地调用CDO来实现（参见我以前的一篇文章http://www.cnblogs.com/Moosdau/archive/2007/09/28/908834.html），但是如果要接收或进行其它一些更复杂一些操作，CDO就无法实现。

事实上，Exchange Server 2003根本不支持与.Net直接交互，据说Exchange Server 2007开放了一组Web Service接口，如果使用了Exchange Server 2007，则可以直接通过Web Service接口直接与Exchange server交互，不过我们公司目前还是使用exchange server 2003，所以也没有测试这组接口要如何使用。

对使用exchange server 2003的环境来说，代价最低的应该说就是调用outlook的功能了，以下列举与outlook交互的一些常用操作。

首先，在项目中添加对outlook组件的引用（Project—>Add Reference—>切换到COM标签页—>选择Microsoft Outlook 14.0 Object Library），这里outlook的具体版本号取决于本地安装的outlook版本，我安装的是outlook 2010，所以显示的版本号是14.0，这个关系不大，各个版本之间的代码似乎是完全相同的。

以下代码列举收件箱中的未读邮件：

var app = new Microsoft.Office.Interop.Outlook.Application();
var ns = app.GetNamespace("MAPI");
ns.Logon("Outlook", Type.Missing, false, false);

var inbox = ns.GetDefaultFolder(Microsoft.Office.Interop.Outlook.OlDefaultFolders.olFolderInbox);
for (int i = 1; i <= inbox.Items.Count; i++)
{
if (inbox.Items[i].UnRead)
{
txtMailList.Text += inbox.Items[i].Subject + System.Environment.NewLine;
}
}
ns.Logoff();
Marshal.ReleaseComObject(inbox);
Marshal.ReleaseComObject(ns);
Marshal.ReleaseComObject(app);
inbox = null;
ns = null;
app = null;

上述代码第三行中出现的“Outlook”字样，这是Outlook自动创建的默认profile名称，如果曾经修改过这个profile，或者本地包含多个profile，或者不确定profile名称，请点击控制面板-->User Accounts-->邮件，如下图：

点击“显示配置文件”：

即可看到配置文件的名称。

用循环枚举收件箱的项目时，需要注意从1开始编号。

如果要读取本地数据文件中的邮件：

var localFolder = ns.Stores["Local"].GetRootFolder().Folders["Archieve"];

如果要删除文件中的邮件，注意每删除一封索引号都会重新编号，所以不能递增循环，而必须从大到小递减循环。

如果需要调用exchange server解析别名的功能：

string alias = "Marvin Yan";
var recipient = app.Session.CreateRecipient(alias);
if (!recipient.Resolve())
{
//alias can't be recoganized.
}

根据recipient获取smtp地址（username@server 格式的邮件地址）：

string mailAddr = recipient.AddressEntry.GetExchangeUser().PrimarySmtpAddress;

如果要回复一封已有邮件：

var mail = item.Reply();
mail.To = item.SenderEmailAddress;
mail.Subject = "Hello";
mail.HTMLBody = "F.Y.I.<br />" + mail.HTMLBody;
mail.Send();

创建一封新的邮件并发送的代码如下：

var mail = app.CreateItem(Microsoft.Office.Interop.Outlook.OlItemType.olMailItem);
mail.HTMLBody = "Hello!";
//Add an attachment.
String attachName = "hello";
int attachPos = (int)mail.Body.Length + 1;
int attachType = (int)Microsoft.Office.Interop.Outlook.OlAttachmentType.olByValue;
//now attached the file
mail.Attachments.Add(@"C:\\hello.txt", attachType, attachPos, attachName);
//Subject line
mail.Subject = "test";
// Add a recipient.
var oRecip = mail.Recipients.Add("xx@xxx.com");
oRecip.Resolve();
// Send.
mail.Send();

本文链接

分布式版本控制系统Mercurial（二）：web server的架设

2012-03-06T15:08:00Z

关于Mercurial的基本功能请参阅分布式版本控制系统Mercurial（一）：Mercurial基本功能介绍

到目前为止，还没有一个比较成熟的Mercurial Web Server软件，所以如果需要通过web访问mercurial的数据仓库，就需要我们手动一步一步地配置，这个过程较为繁琐，应该说这是Mercurial与SVN相比，比较大的一个问题，不过相对于一款极为优秀的工具每天都能给自己提供服务来说，麻烦一次并不算什么。

注意：以下描述的安装过程仅用于Web服务器端。各客户端只需要简单安装tortoisehg with mercirual即可。

1. 环境和版本

我使用的Mercurial版本是2.1, 配了tortoisehg2.3.0. 其中, Mercurial使用的python版本是2.6.6.
操作系统是windows server 2008.

2. 安装过程所需要用到的素材.

a) TortoiseHg 2.3.0 (http://mercurial.selenic.com/downloads/)

b) Mercurial 2.1 Python 2.6 package - x86 Windows
(http://mercurial.selenic.com/downloads/)

c) Python 2.6.6 (http://www.python.org/ftp/python/2.6.6/python-2.6.6.msi)

d) IIS的url rewrite组件(http://www.iis.net/download/URLRewrite) (这个组件只能用于IIS7)

3. 先安装Python2.6.6, 然后安装Mercurial的Python package, 然后安装TortoiseHg, 最后安装url rewrite组件. 当然, 其实也不见得按照这个顺序安装, 只不过如果你不知道应该按何种顺序安装的话,可以参考我这个安装顺序.

4. 在D盘建一个数据仓库总目录, 例如D:\Mercurial, 所有的repositories都将位于这个目录之下.

5. 在IIS中建立一个application, 命名为hg(当然, 你可以随便叫什么名字), 使其物理路径指向d:\Mercurial, 然后编辑其Handler Mappings, 如图所示:

双击Handlers Mappings, 右侧会出现一个actions列表, 点击Add Managed Handler, 会弹出一个新建窗口, 按如下图所示填写这个新建窗口:

6. 在D:\Mercurial下新建一个文本文件, 重命名为test.cgi (注意连同扩展名一起修改) , 编辑其内容如下:

print 'Status: 200 OK'

print 'Content-Type: text/html'

print '<html><body><h1>It Works!</h1></body></html>'

保存, 然后在IIS中浏览test.cgi:

url: http://localhost/hg/test.cgi

界面:

如果能看到上述界面, 说明初期配置成功,继续.

如果提示HTTP 错误 404.2 - Not Found

由于 Web 服务器上的“ISAPI 和 CGI 限制”列表设置，无法提供您请求的页面

打开IIS管理器, 定位到服务器级别, 在其功能列表中找到ISAPI and CGI restrictions, 如图:

双击打开, 里面必须存在如下图所示的行:

如果不存在则按点击右侧的”add”, 按下图填写:

如果已存在, 但是被禁用, 将其启用即可.

完成后重试打开test.cgi, 应该可以看到it works字样.

7. 在D:\Mercurial目录下新建一个文本文件, 重命名为hgweb.cgi, 编辑其内容为以下几句话:

#!/usr/bin/env python

# An example hgweb CGI script, edit as necessary

# See also http://mercurial.selenic.com/wiki/PublishingRepositories

# Path to repo or hgweb config to serve (see 'hg help hgweb')

config = "D:/Mercurial/hgweb.config"

# Uncomment and adjust if Mercurial is not installed system-wide:

#import sys; sys.path.insert(0, "/path/to/python/lib")

# Uncomment to send python tracebacks to the browser if an error occurs:

#import cgitb; cgitb.enable()

from mercurial import demandimport; demandimport.enable()

from mercurial.hgweb import hgweb, wsgicgi

application = hgweb(config)

wsgicgi.launch(application)

然后再在D:\Mercurial下新建一个文本文件, 重命名为hgweb.config, 不需要写入任何内容, 即可尝试浏览http://localhost/hg/hgweb.cgi . 应该能看到如下界面:

如果提示unexpected indent，打开此文件，删除每一行前面的空格即可。

8. 在url中包括一个hgweb.cgi是很不令人喜欢的一件事, 所以本步骤的目的就是消除hgweb.cgi字眼, 如果你觉得没必要, 可以跳过本步骤不看.

第5步在IIS中建立application的时候, IIS会自动在D:\Mercurial目录下创建一个web.config文件, 用任意文本编辑器打开此文件, 在System.webServer节下的handlers节下面增加一个rewrite节, 最终的文件内容如下所示:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.webServer>
<handlers>
<add name="Python" path="*.cgi" verb="*" modules="CgiModule" scriptProcessor="C:\Python26\python.exe -u "%s"" resourceType="Unspecified" requireAccess="Script" />
</handlers>
<rewrite>
<rules>
<clear />
<rule name="hgweb.cgi" enabled="true" patternSyntax="Wildcard">
<match url="*" />
<conditions logicalGrouping="MatchAll" trackAllCaptures="false">
<add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
</conditions>
<action type="Rewrite" url="hgweb.cgi/{R:1}" />
</rule>
</rules>
</rewrite>
<security>
<authorization>
<remove users="*" roles="" verbs="" />
<add accessType="Allow" users="*" />
</authorization>
</security>
</system.webServer>
</configuration>

然后打开hgweb.config, 写入如下内容:

[web]

baseurl = /hg

这时可以尝试浏览http://localhost/hg, 其结果应该和http://localhost/hg/hgweb.cgi完全相同.

9. 测试匿名帐户
现在在D:\Mercurial下建一个名为test的目录, 并在这个目录下执行命令hg init (或tortoisehg的create repository here命令)使得它成为一个hg的仓库. 然后浏览http://localhost/hg, 应该会看到test项目被列举了出来:

这时可以把这个test项目clone到另一个位置, 例如, 在控制台中执行如下命令:

Hg clone http://localhost/hg/test d:\test

就可以把这个测试仓库clone到D:\test, 在D:\test下新建一个文本文件, 然后add & commit, 最后在D:\test下执行hg push, Mercurial会返回一个错误提示: ssl required.

因为此时没有启用SSL, 虽然可以Clone, 但是Mercurial是不允许Push的, 有一个简单的办法可以暂时禁用SSL检查, 打开hgweb.config, 在web节下增加push_ssl=false配置, 如下所示:

[web]

baseurl = /hg

push_ssl = false

这时再尝试push, Mercurial会返回另一个错误提示, abort: authorization failed. 因为现在连接的是匿名用户, 而默认情况下是禁止匿名用户push的, 所以再在hgweb.config的web节下增加一个配置指令: allow_push = *, 如下所示:

[web]

allow_push = *

baseurl = /hg

push_ssl = false

现在重新尝试push, 就会成功了.

10. 其实到现在为止, 如果不考虑安全性和权限管理, 应该说Mercurial的web服务端已经可以正式运行了, 但是在实际应用中, 不考虑安全性是不可能的, 所以我们下面来逐步配置安全性和权限相关的设置. 首先是启用SSL.

打开IIS, 点击选中最顶级的服务器节点, 它有一个Server certificates选项, 如图:

双击, 进入Server certificates选项, 点击右侧Actions列表的Create self-signed certificate, 接下来会弹出一个小窗口, 提示输入证书的名称, 随便起个名字, 例如hgTemp, 确定, 证书即可生成, 如下图所示:

然后, 右击网站节点, 在右键菜单中点击Edit bindings, 如图:

这里是编辑网站与哪个端口绑定的地方, 默认情况下, 这里应该有一个80端口的绑定, 我们先点击Add增加一个443端口, 点击Add后, 填表如下:

另外, 最好把原有的80端口删除, 这样以后这个网站就不允许使用80端口访问, 而必要使用更安全的https:// 前缀来访问了.

也可以在网站这个层级允许80端口, 而只把hg这个虚拟目录配置为要求SSL.

现在, 编辑hgweb.config, 把push_ssl = false 这句话删除, 表示网站对push动作要求必须使用SSL.

先到客户端尝试执行一下clone命令, 会发现Mercurial返回了一个错误提示, 原来Mercurial对我们刚才创建的self-signed certificate是非常不信任的, 它并不承认这个证书, 但是有一个—insecure选项可以用来解决这个问题, 在控制台中执行以下命令:

Clone指令能够成功执行, 但是会返回一个警告, 这个警告很重要, 里面包含一个fingerprint的信息, 把上述警告中的fingerprint copy下来, (即上图中的77:a4……23:96), 找到当前用户的根目录, (C:\Users\user_name), 里面应该有一个mercurial.ini, 用任意文本编辑器打开此ini文件, 参考如下内容修改:

[ui]

username = Marvin Yan <MarvinYan@xxx.com>

[hostfingerprints]

localhost = 77:a4:29:03:bf:27:2b:bf:83:d1:7f:30:79:b7:09:f6:79:cf:23:96

[web]

name =

其中, ui节应该是在安装Mercurial以后就配置好的, 这是Mercurial用户名, 最重要的基本配置之一, 格式为: 用户姓名<邮件地址>.

还有一个web节, name的右侧不用写任何东西, 让Mercurial自动取工作目录为名字即可.

除此两节外, 增加一个hostfingerprints节, 按上述格式写上你自己的fingerprint.

现在再执行hg指令, 不需要增加—insecure参数, 也不再返回任何警告, 都可以成功执行了.

注意：修改mercurial.ini是在客户端执行的，也就是说，每一台客户端都需要执行本步骤以避免安全警告。

11. 身份验证.

打开IIS, 点击虚拟目录hg, 右侧会有相应的Authentication和Authorication rules选项, 如图:

首先双击Authentication, 进入Authentication编辑页面, 默认情况下, Anonymous authentication是被启用的, 先右击, 将它禁用, 这样用户就不能匿名访问这个网站了. 然后在Basic Authentication上右击, 点击Edit, 进入如下的Edit页面:

在Default domain和Realm上分别填入需要验证身份的域(计算机名), 这里需要说明的是: 如果这台Mercurial server处于某个域中, 可以填入域名,这样域中所有的用户都可以访问项目, 当然也可以authorication中进一步筛选, 但是后续的不少操作都受域服务器中策略的影响, 所以我个人不建议直接使用域帐户, 除非你同时也是域服务器的管理员, 那就无所谓了.

不填域名, 而是填上本机的计算机名, 这样进行身份验证的用户实际上就是本机的windwos用户, 进行各种控制相对来说都是比较自由的. 上图中, 我直接填上我的计算机名.

最后不要忘了检查是否已经把Basic authentication的状态改为enable, 并且其它验证都disable掉了.

Authorication rules中, 默认是allow all users的, 建议不必修改, 当然也可以改为specific user, 只允许一部分用户访问, 不过意义不大. 因为可以在windows的用户管理中删除多余的帐户, 保证只留下有效的帐户.

如果使用了本机帐户, 需要注意的是, 一般为本机添加的新用户都是属于User组的, 而User组默认对许多文件夹只有读权限, 而没有写权限, 这时在服务端要在Repo的根目录上给User组写权限, 否则会抛出如下错误:

HTTP Error: 500 (D:\Mercurial\Repos\EERP.Web\.hg/store\00changelog.i:)

[command returned code 255 Fri Mar 02 15:56:42 2012]

12. 自动验证

每一次连接服务器都要输入一次用户名和密码显然是太麻烦了，Mercurial也支持自动验证。打开用户根目录下的Mercurial.ini, 增加[auth] 节如下:

[auth]

default.prefix = https://localhost/

default.username = Marvin

default.password = a

其中, default并没有实质意义, 仅仅为了分组. 可以将default改为任何名字 .

至此，整个Web Server和架设就全部完成。

本文链接

分布式版本控制系统Mercurial（一）：Mercurial基本功能介绍

2012-03-06T14:12:00Z

版本控制系统（Version Control System / Revision Control System，或者叫做源码控制系统Source Control System，以下简称VCS），是软件开发人员最常用的工具之一，由于VCS是如此常用，所以花一些时间去了解它是有必要的。

分布式版本控制系统（Distributed Version Control System,DVCS），是相对于集中式版本控制系统（Centralized Version Control System，CVCS）而言的，比如，使用人数最多的SVN、VSS就是典型的CVCS。如果你曾经用过SVN或VSS，就可以很容易理解什么叫做“Centralized” 。CVCS，是指只有一份数据仓库存放在一台服务器上，所有客户端都连接到这台服务器以读写数据仓库的工作模型。而DVCS模型则不然，每一台终端都有一份完整的数据仓库，所有终端之间都是平等的，并不存在唯一的一台“服务器”。所有的终端之间，可以自由地交换数据。

DVCS可以很容易地模拟CVCS的工作方式，只要指定任意一台终端作为服务器，规定所有人都将更改推送到这台服务器，并且所有人也都从这台服务器获取更新即可。而与CVCS相比，DVCS则有以下优点：

a) 更加安全的代码管理。
在SVN中，每次提交都意味着正式的代码被更改，别人可以立即看到此次提交，并且可能直接影响到正在运行的系统（可能会有人立即将此更新拷贝到服务器），这导致一系列的问题。首先一个问题是，有人可能会无意中提交错误的、不可靠的代码。其次，这导致程序员不敢轻易签入更改，当程序进行一项耗时很久，大量修改的工作时，所有的修改都是没有经过VCS保护的，这是非常危险的，也不符合使用VCS的初衷。

而在DVCS中则不同，因为首先提交到自己本地仓库中，所以程序员可以尽量地向数据仓库提交更改，而不用担心这会影响到其他人或系统，这可以将程序员在开发过程中所产生的各个版本代码完善地保护起来，在周期较长的开发中，这一特点尤其显得重要。

虽然在SVN中有分支功能可以达到类似的目的，但是分支合并操作起来较为繁琐，而且非常容易发生冲突，结果就是很多应当使用分支的场合其实并没有使用分支。

b) 摆脱网络的束缚，随时进行完整的工作。
在SVN中，由于中央仓库只有一个，所以任何需要与仓库沟通的动作（例如查询历史版本，提交更改等等）必须首先联网，而在有些时候，这一束缚就显得不方便，而在DVCS中，则随时可以与数据仓库进行无缝的沟通，程序员可以向其中不停提交新的更改，或查询某个文件的历史版本，都可以在完全断网的情况下进行。

c) 更加智能的代码合并。
当两个人对同一份代码进行工作时，两个人的修改可能会产生冲突。然而，SVN当新的更改被提交时，SVN只能查看最终的版本，这导致SVN对某些差异很大的文件无法自动合并，而人工合并是很费时费力的。在Mercurial中，当两个不同的版本需要进行合并时，DVCS可以使用这个文件所有的修改历史来一步一步地还原整个修改的过程，这样一来，Mercurial的合并能力就远远地超过了SVN，所以在Mercurial中，极少会出现人工合并的问题。

d) 更快的反应速度. 由于各种日常操作都是在开发人员的本机进行的, 所以与任何的CVCS相比, DVCS的操作反应速度都将快很多倍.

另外，对于个人项目来说，尤其适合使用DVCS，因为DVCS天然地擅长管理本地的数据仓库，不像CVCS那样必须架设一个服务端，一个客户端。

因此总的来说，分布式结构的Mercurial具有SVN的所有优点，而又比SVN更加合理有效。

目前的DVCS最主要有Mercurial和Git两款软件，其中Git的原作者是Linus大神，用C语言编写，运行性能优于Mercurial（Mercurial是用Python写的，天生注定性能不可能比Git更快），但是Linus以及最初的开发团队并不打算开发Windows版本的Git，所以Git本身并不支持Windows，后来有了一个msysgit项目将Git移植到了windows平台，并且有了开发了一个TortoiseGit客户端，使得Git在windows下也变得容易使用了，但是在我使用的过程中，连续发生多次严重的故障，我怀疑其在windows下还不够成熟，因此采用与操作系统兼容完美的Mercurial。 Mercurial这个单词是水银的意思，所以Mercurial的命令名采用了水银的化学元素符号hg，这也是为什么它的图形终端叫做TortoiseHg，而不是TortoiseMercurial之类的。

这里（http://hgbook.red-bean.com/read/）有一份完整的Mercurial文档，详细描述了Mercurial的各种细节，不过鉴于其是英文的，我简单再罗列一下Mercurial的基本用法。

首先，下载并安装一个TortoiseHg with Mercurial(http://tortoisehg.bitbucket.org/), TortoiseHg是一个图形化的客户端，集成于Windows explorer，与TortoiseSVN是极为类似的。这个安装包同时集成了Mercurial的主程序，所以只要装这一个就够了。（Mercurial并不需要一个服务器端）

安装完成以后，打开Windows explorer，在任意位置右击，即可看到如下所示的TortoiseHg菜单：

这里需要先设置一下用户信息,因为Mercurial提交的时候需要知道用户名以便记录历史,所以必须首先配置用户名. 在上图菜单中点击Global Settings, 在弹出选项窗中的Commit子页中:

其中用户名的格式一般为"姓名<邮箱>" . 写完以后保存即可.

Clone命令用于从其它位置复制一个数据仓库，而Create repository here当然就是在当前文件夹创建仓库了，这里我们先创建一个仓库。

或者也可以不使用TortoiseHg的图形界面，直接用Mercurial命令创建。

Windows7有一个隐藏的右键菜单，当住shift不放点右键时，会发现右键菜单多了几项，其中就有一个是open command here，这会打开一个cmd命令窗，路径就是当前文件夹，直接输入命令hg init，即可完成数据仓库的创建。

（以前我也不喜欢用命令，但是使用Mercurial以后，我发现其实用命令并不麻烦，很多时候比TortoiseHg来得还要舒服一些）

创建数据仓库以后，再次右击，会发现首先在一级右键菜单上增加了Hg Commit选项，而子项中则出现了一大排可用命令。这些暂时不用去理它。

随便新建一个文本文件，点击hg commit，输入一点注释（Mercurial强制要求每次commit必须写注释），点击提交即可。

注意左侧的文件列表，必须先打上勾。因为是向Mercurial新增文件，所以必须先执行add命令，然后才能commit，体现在这个图形界面上，就是先勾上左边，再点commit。

如果使用命令，则分别输入：

hg add

hg commit –m “some comment here”

第一行hg add会将所有新增的文件标记为需要Mercurial进行追踪管理，第二句则是向数据仓库提交修改。

这里需要注意的是Update命令。Mercurial的Update与SVN在实际效果上差异巨大。Update是用于使工作目录与本地数据仓库之间保持一致。所以，如果你是单人项目，总是在工作目录提交修改的话，它们肯定是完全一致的，Update命令将永远不必执行。（这大约也是为什么TortoiseHg把Update命令作为二级命令而不像Commit那样是一级菜单命令）那么什么时候需要Update？先看一下push和pull。

假定我们刚才创建的仓库位于D:\repo1，现在执行命令hg clone d:\repo1 d:\repo2，或者在tortoisehg上点击clone执行相应操作（图形界面不再一一截图，很简单的操作），这样就创建了一个新的仓库repo2，它与repo1是完全相同的。现在向repo1提交另外一些修改，显而易见的，repo2仍然停留在clone时的状态，repo1的最新修改repo2并不知道。如果现在希望repo2也能更新到repo1的最新状态，则有两种操作方式：

1. Push。 Push顾名思义，是推送的意思，就是从repo1中推送数据到repo2， repo2 不需要做任何动作。在repo1目录下执行命令hg push d:\repo2。或者点击tortoisehg的Syncronize，在同步窗口中点击push命令：

（这种操作我实在觉得还是命令方便一些。。。）

其中，push命令后面的路径并不是必须的。每个数据仓库可以有一个默认的远程仓库，如果在repo1中设置了默认远程仓库为repo2，则只需要执行hg push 就可以了。当执行clone命令时，会自动把来源仓库设为默认远程仓库，所以在repo2中可以直接执行hg push或hg pull，会自动到repo1中同步数据。

因为repo1并不知道repo2的存在，所以如果需要手动设置默认远程仓库，如下这样操作：

点击右键—>TortoiseHg—>Repository settings,

点击Edit file, 如图所示, 修改default为需要指定的路径即可.

修改完成以后,即可直接执行hg push 而不用写成hg push d:\repo2了.

2. Pull. Pull是拉取的意思, 即被更新的仓库主动从远程仓库拉取数据. 在本例中, 到repo1的目录下执行hg pull即可. 因为repo2是从repo1 clone来的, 所以repo2已经自动把repo1设置默认远程仓库, 不需要再写hg pull d:\repo1了.

所以,无论是从repo1端push, 还是从repo2端pull, 都可以达到更新repo2数据仓库的目的.

然而需要注意的是, 无论是push还是pull, 都只更新数据仓库, 而不更新工作目录.

记住这一点非常重要, 否则可能经常会迷惑为什么与预期不符. push或pull之后, repo2的数据仓库与工作目录已经不符, 这时就需要在repo2目录下执行hg update命令, 即可将工作目录更新到与数据仓库一致.

当像SVN那样使用远程服务器作为主机时, 每次Pull后可以肯定是要执行update的, 这样两次操作显然带来不便, 在TortoiseHg中, 已经集成了这样的命令, 首先右键—>TortoiseHg—>Syncronize, 打开同步窗口,

点击Post Pull, 在弹出的小窗口中选择Update, 这样每次pull之后就会立即执行update了.

或者在项目的根目录下写一个批处理文件, 包括以下两行即可:

hg pull

hg update

以后每次需要获取更新时, 双击一下这个批处理即可, 我觉得还是命令方便……

以上简单罗列了Mercurial的基本用法, 对于查询历史修改等操作, TortoiseHg的菜单已经非常简单, 与SVN也没有什么差别, 自行点击看一下即可.

关于在两台电脑之间传递数据，Mercurial自带了一个简单的Serve命令，例如在d:\repo1目录下执行命令hg server，会立即启动一个默认在8000端口监听的服务进程，这个命令会返回一个url地址，另一台电脑可以用hg clone <url> local-path 的形式复制本机的repo1仓库，但是这个serve命令显然只是一个非常简单的临时途径，如果要配置一台作为服务器的中央仓库，当然就不能仅仅使用serve命令了，而是应该使用IIS或其它web server，下一篇就介绍如何在IIS上架设一个Mercurial的Web Server,请参阅分布式版本控制系统Mercurial（二）：web server的架设

本文链接

C#将汉字转换为拼音首字母

2011-12-06T03:23:00Z

关于这个话题以前曾经使用过一个简便的算法很长时间, 代码如下:

private string ToPinyinSingle(string str)
        {
            if (str.CompareTo("吖") < 0)
                return str;
            if (str.CompareTo("八") < 0)
                return "a";
            if (str.CompareTo("嚓") < 0)
                return "b";
            if (str.CompareTo("咑") < 0)
                return "c";
            if (str.CompareTo("妸") < 0)
                return "d";
            if (str.CompareTo("发") < 0)
                return "e";
            if (str.CompareTo("旮") < 0)
                return "f";
            if (str.CompareTo("铪") < 0)
                return "g";
            if (str.CompareTo("讥") < 0)
                return "h";
            if (str.CompareTo("咔") < 0)
                return "j";
            if (str.CompareTo("垃") < 0)
                return "k";
            if (str.CompareTo("嘸") < 0)
                return "l";
            if (str.CompareTo("拏") < 0)
                return "m";
            if (str.CompareTo("噢") < 0)
                return "n";
            if (str.CompareTo("妑") < 0)
                return "o";
            if (str.CompareTo("七") < 0)
                return "p";
            if (str.CompareTo("亽") < 0)
                return "q";
            if (str.CompareTo("仨") < 0)
                return "r";
            if (str.CompareTo("他") < 0)
                return "s";
            if (str.CompareTo("哇") < 0)
                return "t";
            if (str.CompareTo("夕") < 0)
                return "w";
            if (str.CompareTo("丫") < 0)
                return "x";
            if (str.CompareTo("帀") < 0)
                return "y";
            if (str.CompareTo("咗") < 0)
                return "z";
            return str;

}

这个函数只处理单个汉字, 简单地加个循环就可以让它处理文字串了.

在.net 3.5下, 它一直工作得很好, 虽然偶尔也有出错的时候, 但是概率极低, 基本上可以忽略不计.

然而后来我把项目升级到.net 4.0以后, 发现出错的几率直线上升, 已经高得无法容忍的程度了(例如, "梅" 会返回"L"), 简单查了一下, 没找到微软关于String.CompareTo函数有什么变化的说明, 束手无策, 于是换用另一个也很简单的算法(http://topic.csdn.net/u/20090219/12/61745e3a-a39e-4f4d-8985-67d124236694.html):

static public string getSpell(string cn)
{
byte[] arrCN = System.Text.Encoding.Default.GetBytes(cn);
if(arrCN.Length > 1)
{
int area = (short)arrCN[0];
int pos = (short)arrCN[1];
int code = (area<<8) + pos;
int[] areacode = {45217,45253,45761,46318,46826,47010,47297,47614,48119,48119,49062,49324,49896,50371,50614,50622,50906,51387,51446,52218,52698,52698,52698,52980,53689,54481};
for(int i=0;i<26;i++)
{
int max = 55290;
if(i != 25) max = areacode[i+1];
if(areacode[i]<=code && code<max)
{
return System.Text.Encoding.Default.GetString(new byte[]{(byte)(65+i)});
}
}
return "?";
}
else return cn;

}

但是这个函数出错的概率也很高, 例如"闫""窦""圳" 等都无法识别, 追查了一下原因, 发现原来对GB2312编码来说, 存放规定是这样的:

01-09区为特殊符号。

16-55区为一级汉字，按拼音排序。

56-87区为二级汉字，按部首/笔画排序。

每个汉字及符号以两个字节来表示。第一个字节称为“高位字节”，第二个字节称为“低位字节”。

“高位字节”使用了0xA1-0xF7(把01-87区的区号加上0xA0)，“低位字节”使用了0xA1-0xFE(把01-94加上0xA0)。

例如“啊”字在大多数程序中，会以0xB0A1储存。（与区位码对比：0xB0=0xA0+16,0xA1=0xA0+1）

上述几个字位置码都大于55290, 显然是二级汉字, 这个算法就处理不了了, 换言之, 这种写法只能用于处理一级汉字. 这当然是不可接受的.

后来翻查良久, 终于找到一个用C++写的算法, 可以同时处理一级汉字和二级汉字(http://download.csdn.net/detail/ronjay/1955072), 我把它改写成了C#, 代码如下:

  public class ChineseToPinYin
        {
            #region " 全局变量 "

            private static string[] _regionChar = new string[32]
            {
                "CJWGNSPGCGNESYPBTYYZDXYKYGTDJNNJQMBSGZSCYJSYYQPGKBZGYCYWJKGKLJSWKPJQHYTWDDZLSGMRYPYWWCCKZNKYDG",
                "TTNGJEYKKZYTCJNMCYLQLYPYQFQRPZSLWBTGKJFYXJWZLTBNCXJJJJZXDTTSQZYCDXXHGCKBPHFFSSWYBGMXLPBYLLLHLX",
                "SPZMYJHSOJNGHDZQYKLGJHSGQZHXQGKEZZWYSCSCJXYEYXADZPMDSSMZJZQJYZCDJZWQJBDZBXGZNZCPWHKXHQKMWFBPBY",
                "DTJZZKQHYLYGXFPTYJYYZPSZLFCHMQSHGMXXSXJJSDCSBBQBEFSJYHWWGZKPYLQBGLDLCCTNMAYDDKSSNGYCSGXLYZAYBN",
                "PTSDKDYLHGYMYLCXPYCJNDQJWXQXFYYFJLEJBZRXCCQWQQSBNKYMGPLBMJRQCFLNYMYQMSQTRBCJTHZTQFRXQHXMJJCJLX",
                "QGJMSHZKBSWYEMYLTXFSYDSGLYCJQXSJNQBSCTYHBFTDCYZDJWYGHQFRXWCKQKXEBPTLPXJZSRMEBWHJLBJSLYYSMDXLCL",
                "QKXLHXJRZJMFQHXHWYWSBHTRXXGLHQHFNMNYKLDYXZPWLGGTMTCFPAJJZYLJTYANJGBJPLQGDZYQYAXBKYSECJSZNSLYZH",
                "ZXLZCGHPXZHZNYTDSBCJKDLZAYFMYDLEBBGQYZKXGLDNDNYSKJSHDLYXBCGHXYPKDJMMZNGMMCLGWZSZXZJFZNMLZZTHCS",
                "YDBDLLSCDDNLKJYKJSYCJLKOHQASDKNHCSGANHDAASHTCPLCPQYBSDMPJLPCJOQLCDHJJYSPRCHNWJNLHLYYQYYWZPTCZG",
                "WWMZFFJQQQQYXACLBHKDJXDGMMYDJXZLLSYGXGKJRYWZWYCLZMSSJZLDBYDCFCXYHLXCHYZJQSFQAGMNYXPFRKSSBJLYXY",
                "SYGLNSCMHCWWMNZJJLXXHCHSYDSTTXRYCYXBYHCSMXJSZNPWGPXXTAYBGAJCXLYSDCCWZOCWKCCSBNHCPDYZNFCYYTYCKX",
                "KYBSQKKYTQQXFCWCHCYKELZQBSQYJQCCLMTHSYWHMKTLKJLYCXWHEQQHTQHZPQSQSCFYMMDMGBWHWLGSSLYSDLMLXPTHMJ",
                "HWLJZYHZJXHTXJLHXRSWLWZJCBXMHZQXSDZPMGFCSGLSXYMJSHXPJXWMYQKSMYPLRTHBXFTPMHYXLCHLHLZYLXGSSSSTCL",
                "SLDCLRPBHZHXYYFHBBGDMYCNQQWLQHJJZYWJZYEJJDHPBLQXTQKWHLCHQXAGTLXLJXMSLXHTZKZJECXJCJNMFBYCSFYWYB",
                "JZGNYSDZSQYRSLJPCLPWXSDWEJBJCBCNAYTWGMPAPCLYQPCLZXSBNMSGGFNZJJBZSFZYNDXHPLQKZCZWALSBCCJXJYZGWK",
                "YPSGXFZFCDKHJGXDLQFSGDSLQWZKXTMHSBGZMJZRGLYJBPMLMSXLZJQQHZYJCZYDJWBMJKLDDPMJEGXYHYLXHLQYQHKYCW",
                "CJMYYXNATJHYCCXZPCQLBZWWYTWBQCMLPMYRJCCCXFPZNZZLJPLXXYZTZLGDLDCKLYRZZGQTGJHHHJLJAXFGFJZSLCFDQZ",
                "LCLGJDJCSNCLLJPJQDCCLCJXMYZFTSXGCGSBRZXJQQCTZHGYQTJQQLZXJYLYLBCYAMCSTYLPDJBYREGKLZYZHLYSZQLZNW",
                "CZCLLWJQJJJKDGJZOLBBZPPGLGHTGZXYGHZMYCNQSYCYHBHGXKAMTXYXNBSKYZZGJZLQJDFCJXDYGJQJJPMGWGJJJPKQSB",
                "GBMMCJSSCLPQPDXCDYYKYFCJDDYYGYWRHJRTGZNYQLDKLJSZZGZQZJGDYKSHPZMTLCPWNJAFYZDJCNMWESCYGLBTZCGMSS",
                "LLYXQSXSBSJSBBSGGHFJLWPMZJNLYYWDQSHZXTYYWHMCYHYWDBXBTLMSYYYFSXJCSDXXLHJHFSSXZQHFZMZCZTQCXZXRTT",
                "DJHNNYZQQMNQDMMGYYDXMJGDHCDYZBFFALLZTDLTFXMXQZDNGWQDBDCZJDXBZGSQQDDJCMBKZFFXMKDMDSYYSZCMLJDSYN",
                "SPRSKMKMPCKLGDBQTFZSWTFGGLYPLLJZHGJJGYPZLTCSMCNBTJBQFKTHBYZGKPBBYMTTSSXTBNPDKLEYCJNYCDYKZDDHQH",
                "SDZSCTARLLTKZLGECLLKJLQJAQNBDKKGHPJTZQKSECSHALQFMMGJNLYJBBTMLYZXDCJPLDLPCQDHZYCBZSCZBZMSLJFLKR",
                "ZJSNFRGJHXPDHYJYBZGDLQCSEZGXLBLGYXTWMABCHECMWYJYZLLJJYHLGBDJLSLYGKDZPZXJYYZLWCXSZFGWYYDLYHCLJS",
                "CMBJHBLYZLYCBLYDPDQYSXQZBYTDKYXJYYCNRJMPDJGKLCLJBCTBJDDBBLBLCZQRPPXJCGLZCSHLTOLJNMDDDLNGKAQHQH",
                "JGYKHEZNMSHRPHQQJCHGMFPRXHJGDYCHGHLYRZQLCYQJNZSQTKQJYMSZSWLCFQQQXYFGGYPTQWLMCRNFKKFSYYLQBMQAMM",
                "MYXCTPSHCPTXXZZSMPHPSHMCLMLDQFYQXSZYJDJJZZHQPDSZGLSTJBCKBXYQZJSGPSXQZQZRQTBDKYXZKHHGFLBCSMDLDG",
                "DZDBLZYYCXNNCSYBZBFGLZZXSWMSCCMQNJQSBDQSJTXXMBLTXZCLZSHZCXRQJGJYLXZFJPHYMZQQYDFQJJLZZNZJCDGZYG",
                "CTXMZYSCTLKPHTXHTLBJXJLXSCDQXCBBTJFQZFSLTJBTKQBXXJJLJCHCZDBZJDCZJDCPRNPQCJPFCZLCLZXZDMXMPHJSGZ",
                "GSZZQJYLWTJPFSYASMCJBTZKYCWMYTCSJJLJCQLWZMALBXYFBPNLSFHTGJWEJJXXGLLJSTGSHJQLZFKCGNNDSZFDEQFHBS",
                "AQTGLLBXMMYGSZLDYDQMJJRGBJTKGDHGKBLQKBDMBYLXWCXYTTYBKMRTJZXQJBHLMHMJJZMQASLDCYXYQDLQCAFYWYXQHZ"
            };
            private static System.Text.Encoding _encoding = System.Text.Encoding.GetEncoding("GB2312");

            #endregion

            private static bool In(int lp, int hp, int value)
            {
                return ((value <= hp) && (value >= lp));
            }
            public static char GetFirstChar(string chineseChar)
            {
                var bytes = _encoding.GetBytes(chineseChar);
                if (bytes.Length != 2)
                    return chineseChar[0];
                return GetChar(bytes[0], bytes[1], chineseChar);
            }
            private static char GetChar(byte c1, byte c2, string originChar)
            {
                var Hi = c1 << 8;
                var Lo = c2;
                int n = Hi + Lo;
                if (n <= 0xD7F9)
                {
                    if (In(0xB0A1, 0xB0C4, n)) return 'A';
                    if (In(0XB0C5, 0XB2C0, n)) return 'B';
                    if (In(0xB2C1, 0xB4ED, n)) return 'C';
                    if (In(0xB4EE, 0xB6E9, n)) return 'D';
                    if (In(0xB6EA, 0xB7A1, n)) return 'E';
                    if (In(0xB7A2, 0xB8C0, n)) return 'F';
                    if (In(0xB8C1, 0xB9FD, n)) return 'G';
                    if (In(0xB9FE, 0xBBF6, n)) return 'H';
                    if (In(0xBBF7, 0xBFA5, n)) return 'J';
                    if (In(0xBFA6, 0xC0AB, n)) return 'K';
                    if (In(0xC0AC, 0xC2E7, n)) return 'L';
                    if (In(0xC2E8, 0xC4C2, n)) return 'M';
                    if (In(0xC4C3, 0xC5B5, n)) return 'N';
                    if (In(0xC5B6, 0xC5BD, n)) return 'O';
                    if (In(0xC5BE, 0xC6D9, n)) return 'P';
                    if (In(0xC6D1, 0xC8BA, n)) return 'Q';
                    if (In(0xC8BB, 0xC8F5, n)) return 'R';
                    if (In(0xC8F6, 0xCBF9, n)) return 'S';
                    if (In(0xCBFA, 0xCDD9, n)) return 'T';
                    if (In(0xCDDA, 0xCEF3, n)) return 'W';
                    if (In(0xCEF4, 0xD1B8, n)) return 'X';
                    if (In(0xD1B9, 0xD4D0, n)) return 'Y';
                    if (In(0xD4D1, 0xD7F9, n)) return 'Z';
                    return originChar[0];
                }
                else
                {
                    var b1 = (c1 & 0x7F) - 0x20 - 56;
                    var b2 = (c2 & 0x7F) - 0x20 - 1;
                    if (b1 >= 0 && b1 <= 31 && b2 >= 0 && b2 <= 93)
                    {
                        return _regionChar[b1][b2];
                    }
                    return originChar[0];
                }
            }

}

这个算法目前还没有发现哪个汉字会出错.

本文链接

nbsp空格

2011-06-28T02:06:00Z

对GridView这样的控件, 取它的Rows[i].Cell[j].Text是件很危险的事情, 因为它会把许多符号转码成类似  这样的转义符, 虽然从前台看起来是正确显示了的, 但是在后台取值时就会把转义符本身取出来, 所以在程序中如果需要读取某格的Text, 还需要先Server.HtmlDecode一下.

在被自动转义的符号中, 空格是特别诡异的一种, 因为即使数据源中没有空格, 它也能自动产生出来, 比如数据源该列是日期型, null, 但是呈现时, 在html里面就给生成出个 来,  代表空格, 一般来说, 多出来个空格也没什么, 不过今天程序碰到个怪现象, 把它存入文本框, 再重新读出的时候, 这个空格自动变成了问号! 这事情虽然奇怪, 查起来也容易, 观察一下这个字符的ASCII值, 发现值是160, 而正常的空格应该是32, 这就怪不得会变成问号了, 因为标准的ASCII字符只有128个, 超过127的都会无法识别, 而显示为问号, 问题是, 怎么会出现个160空格?

查了一下资料, 这才发现nbsp空格在定义上与普通空格就是不一样的, 它代表Non-breaking space. 所以它的ASCII值不同于普通空格. 而之所以文本框没有正确识别这个空格, 则是受globalization配置的影响, 以前在globalization中, 我设置的requestEncoding和responseEncoding都是utf-8, 最近测试时改成了GB2312, 经过这次事件也证明用GB2312作为encoding方式是不行的, 它会导致扩展ascii字符不能被正确解读(汉字是可以的).

本文链接

VS2010 targetFramework 错误

2011-04-28T03:03:00Z

今天偶然在一个项目中发现var关键字附近被标记了语法错误, 一看提示:

Feature 'implicitly typed local variable' cannot be used because it is not part of the ISO-2 C# language specification

嗯? 我的项目明明一直是.net 3.5来着, 想了想, 大约是因为前几天我把项目从file system切换到iis时, vs推断framework出了故障, 于是用记事本打开.sln文件, 发现如下一行:

把最后那个2.0 改成3.5, vs要求重新加载解决方案, reload一下, ok了.

本文链接

在网络上共享条码打印机

2011-04-21T06:09:00Z

原来写过一篇C#打印条码与ZPL, 是打印到本地的打印机, 但是往往会需要程序使用远程的打印机进行打印, 其实基本上做法是一致的, 只是把命令发送到打印机的地方修改一下. 具体发送指令的代码微软已经提供了完整的范本: http://support.microsoft.com/kb/322091, 其实只要看一个这篇文章, 基本上就不会有问题了, 不过为了防止以后链接失效, 还是演练一下吧:

在IP地址172.16.8.1 上安装一台打印机, 名为”Argox OS-214 Zip”, 并将其共享, 在开发机上打开\\172.16.8.1, 会看到共享的打印机, 右击—>然后open或connect, 都会自动安装此打印机的驱动到本地, 安装完成以后, 新建一个windows form application, 新增一个类, 然后删除这个新类的所有代码, 把以下代码复制过去:

using System;
using System.Drawing;
using System.Drawing.Printing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;

public class RawPrinterHelper
{
// Structure and API declarions:
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public class DOCINFOA
{
[MarshalAs(UnmanagedType.LPStr)]
public string pDocName;
[MarshalAs(UnmanagedType.LPStr)]
public string pOutputFile;
[MarshalAs(UnmanagedType.LPStr)]
public string pDataType;
}
[DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string szPrinter, out IntPtr hPrinter, IntPtr pd);

[DllImport("winspool.Drv", EntryPoint = "ClosePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool ClosePrinter(IntPtr hPrinter);

[DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool StartDocPrinter(IntPtr hPrinter, Int32 level, [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);

[DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool EndDocPrinter(IntPtr hPrinter);

[DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool StartPagePrinter(IntPtr hPrinter);

[DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool EndPagePrinter(IntPtr hPrinter);

[DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, out Int32 dwWritten);

// SendBytesToPrinter()
// When the function is given a printer name and an unmanaged array
// of bytes, the function sends those bytes to the print queue.
// Returns true on success, false on failure.
public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)
{
Int32 dwError = 0, dwWritten = 0;
IntPtr hPrinter = new IntPtr(0);
DOCINFOA di = new DOCINFOA();
bool bSuccess = false; // Assume failure unless you specifically succeed.

di.pDocName = "My C#.NET RAW Document";
di.pDataType = "RAW";

// Open the printer.
if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
{
// Start a document.
if (StartDocPrinter(hPrinter, 1, di))
{
// Start a page.
if (StartPagePrinter(hPrinter))
{
// Write your bytes.
bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
EndPagePrinter(hPrinter);
}
EndDocPrinter(hPrinter);
}
ClosePrinter(hPrinter);
}
// If you did not succeed, GetLastError may give more information
// about why not.
if (bSuccess == false)
{
dwError = Marshal.GetLastWin32Error();
}
return bSuccess;
}

public static bool SendFileToPrinter(string szPrinterName, string szFileName)
{
// Open the file.
FileStream fs = new FileStream(szFileName, FileMode.Open);
// Create a BinaryReader on the file.
BinaryReader br = new BinaryReader(fs);
// Dim an array of bytes big enough to hold the file's contents.
Byte[] bytes = new Byte[fs.Length];
bool bSuccess = false;
// Your unmanaged pointer.
IntPtr pUnmanagedBytes = new IntPtr(0);
int nLength;

nLength = Convert.ToInt32(fs.Length);
// Read the contents of the file into the array.
bytes = br.ReadBytes(nLength);
// Allocate some unmanaged memory for those bytes.
pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
// Copy the managed byte array into the unmanaged array.
Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
// Send the unmanaged bytes to the printer.
bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, nLength);
// Free the unmanaged memory that you allocated earlier.
Marshal.FreeCoTaskMem(pUnmanagedBytes);
return bSuccess;
}
public static bool SendStringToPrinter(string szPrinterName, string szString)
{
IntPtr pBytes;
Int32 dwCount;
// How many characters are in the string?
dwCount = szString.Length;
// Assume that the printer is expecting ANSI text, and then convert
// the string to ANSI text.
pBytes = Marshal.StringToCoTaskMemAnsi(szString);
// Send the converted ANSI string to the printer.
SendBytesToPrinter(szPrinterName, pBytes, dwCount);
Marshal.FreeCoTaskMem(pBytes);
return true;
}
}

然后在我们的form1上拖一个按钮, 双击此按钮进行点击事件, 贴入以下代码:

private void button1_Click(object sender, EventArgs e)
{
var sb = new System.Text.StringBuilder();
sb.AppendLine("^XA ");
sb.AppendLine("^FO30,30");
sb.AppendLine("^FDHello World!^FS");
sb.AppendLine("^XZ ");

string printerName = @"\\172.16.8.1\Argox OS-214 Zip";
RawPrinterHelper.SendStringToPrinter(printerName, sb.ToString());
}

F5运行, 点击按钮, 会看到打印机已经打印了一个Hello world出来, 打完收工.

本文链接

WCF身份验证之二:使用MessageHeader进行验证

2011-04-20T12:24:00Z

关于这个主题, 还有一篇 WCF身份验证之一:使用证书进行验证.

关于使用SoadHeader验证Robin已经有一篇十分精彩的文章: WCF进阶:为每个操作附加身份信息, 不过我的思维方式总是跟别人有点不太一样, 还是把类似的内容用我的方式重新组织一下.

使用Header验证最直接的想法就是不要使用证书, 证书在很多场合都显得太过于复杂了, 而我们对安全性的要求并没有那么高, 毕竟我们周围的环境中有能力截取网络中的通信数据并筛选中敏感信息, 而且有动机加以利用破坏的人怎么看都像是还没出生.

下面开始演练:

打开vs, 创建一个新的WCF Service Library, 我保持了它的默认名字WcfServiceLibrary4, 然后向解决方案添加一个windows forms application, 名字为WindowsFormsApplication1, 作为我们的客户端, 在客户端添加服务引用, 直接点discover, 即可引用我们刚创建的WcfServiceLibrary4, 如图所示:

然后在客户端窗体上拖一个按钮, 给它的点击事件写两行代码以调用服务:

private void button1_Click(object sender, EventArgs e)
{
var proxy = new ServiceReference1.Service1Client();
MessageBox.Show(proxy.GetData(3));
}

运行一下, 会看到服务被正确执行了.

现在开始添加身份验证的逻辑. 首先, 对客户端来说, 基本思想是每发出一个服务请求之前, 添加一个header, 所以就有了如下这个类:

public class MyInspector : IClientMessageInspector
{
public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
{
}

public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel)
{
request.Headers.Add(MessageHeader.CreateHeader("Password", "gb", "123"));
return null;
}
}

这个类只是简单继承了IClientMessageInspector接口, 并添加了一个MessageHeader, 明显它不可能直接就起作用, 需要另一个机制把它与服务请求绑定起来, 于是就有了下面这个类:

public class MyEndPointBehavior : IEndpointBehavior
{

public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
{
}

public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
clientRuntime.MessageInspectors.Add(new MyInspector());
}

public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
}

public void Validate(ServiceEndpoint endpoint)
{
}
}

这个类负责将刚创建的Inspector添加到EndPoint的behavior当中, 但是这个类自身仍然是悬空的, 所以继续(这个类需要引用System.Configuration):

public class MyBehaviorExtension : BehaviorExtensionElement
{

public override Type BehaviorType
{
get { return typeof(MyEndPointBehavior); }
}

protected override object CreateBehavior()
{
return new MyEndPointBehavior();
}
}

再创建一个Extension类, 负责把MyEndPointBehavior类与当前的服务实例关联起来, 但是同样的问题, 这个类自身还没有被调用, ----不用再创建下一个类了, 这个类将通过app.config与服务进行绑定:

在app.config的system.serviceModel下, 添加一个自定义的behavior:

然后将已有的endPoint与此behavior关联起来:

此EndPoint的配置中只有蓝框里面是手动新增的, 其它都是自动生成. 现在这个空的behavior已经被应用到了具体的endpoint, 接下来需要把这个behavior具体化, 先来增加一个extension:

需要注意的是, 这个extension的type必须是我们刚才最后添加的那个MyBehaviorExtension类的AssemblyQualifiedName, 并且中间不允许有任何的空格, 回车等.

接下来, 将这个extension与空的behavior关联起来:

关联的方法很简单, 就是增加一个节点, 名字就是新增加的extension的Name.

现在, 我们终于全线贯通了, 出发点是endpoint, 为默认的endpoint增加一个behavior, 这个behavior有一个我们自定义的extension, 这个extension会创建一个自定义的endpointbehavior, 在这里最终添加了inspector. 来测试一下吧: 在inspector中下一个断点, 执行程序, 会发现断点确实被执行了, 至此, 客户端的配置就结束了, 每一次调用服务时, 都会附加一个名为Password的header, 这就是我们的目的.

然后是服务端, 服务端需要检测是否传递了password, password的值是否正确, 如果正确才会继续提供服务. 总的流程与客户端基本一致, 唯一的区别是将IClientMessageInspector换成了IDispatchMessageInspector, 具体的几个类的代码如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Description;
using System.ServiceModel.Channels;
using System.ServiceModel.Configuration;

namespace WcfServiceLibrary4
{
class MyInspector : IDispatchMessageInspector
{

public object AfterReceiveRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel, System.ServiceModel.InstanceContext instanceContext)
{
if (request.Headers.FindHeader("Password", "gb") < 0 ||
request.Headers.GetHeader<string>("Password", "gb") != "123")
throw new UnauthorizedAccessException();
return null;
}

public void BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
{
}
}

public class MyEndPointBehavior : IEndpointBehavior
{

public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
{
}

public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
}

public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
endpointDispatcher.DispatchRuntime.MessageInspectors.Add(new MyInspector());
}

public void Validate(ServiceEndpoint endpoint)
{
}
}

public class MyBehaviorExtension : BehaviorExtensionElement
{

public override Type BehaviorType
{
get { return typeof(MyEndPointBehavior); }
}

protected override object CreateBehavior()
{
return new MyEndPointBehavior();
}
}

}

App.config 的配置和客户端基本上完全相同, 只有最终的extension的type换成服务端的类型全名即可.

然后重新运行项目, 在服务端的检查口令的地方下个断点, 可以确定这里被运行到了, 这就全部完工了.

当然, 也可以把这服务端和客户端总共用到的三个接口, 一个基类全部合在一个类中实现, (比如Robin的实现) 这样可以在客户端和服务端之间共享代码, 以及类名就只剩一个了, 不过我觉得还是按它本来的面目拆开来写比较容易理解, 至于理解了之后如何优化, 那就完全自由发挥了.

本文链接

WCF身份验证之一:使用证书进行验证

2011-04-17T09:35:00Z

WCF服务是个讨人喜欢的东西, 但是每个网络中的人都可以任意使用服务, 这就是个问题了, 这一组文章简单列举几种身份验证的方法. 本篇文章讨论的是证书验证.

使用X509证书进行身份验证应该说是WCF安全模型中最”正常”的做法, 因为WCF强制要求使用证书加密身份数据, 离开了证书, 所有的身份验证机制拒绝工作, WCF支持的身份验证机制也相当复杂, 这里仅为了让程序按照我们的期望动起来, 所以并不展开讨论其它的验证方法, 有了一种做法做为基础, 也很容易查到其它的实现方法.

1. 本文所使用的软件环境:
windows 7
Visual studio 2010

2. 用vs创建一个"WCF Service Library” 项目, 此时生成一个默认的IService1接口, 一个默认的GetData函数. 在当前解决方案中再增加一个Windows Forms Application项目, 作为服务的测试客户端, 直接在client中添加服务引用, 然后discover一下, Service1就显示出来了, 直接确定.

3. 现在开始写代码, 在client的form上放一个按钮, 在此按钮的点击事件中写上对服务的调用:

var proxy = new ServiceReference1.Service1Client();
MessageBox.Show(proxy.GetData(0));

把client项目设为起始项目, F5运行, 点击按钮:

4. 测试完成, 我们的基础环境没有任何问题. 现在开始考虑身份验证的问题, 首先, 我们采用用户名/密码的模式进行验证, 这就需要有一个验证用户名密码的地方: 在服务项目中添加引用System.IdentityModel, 然后向服务添加一个类, 这里将此类命名为Validator, 这个类的实现如下:

class Validator : System.IdentityModel.Selectors.UserNamePasswordValidator
{
public override void Validate(string userName, string password)
{
if (userName != "u" || password != "p")
throw new UnauthorizedAccessException();
}
}

然后右击服务项目的app.config, 选择Edit WCF Configuration.

5. 为默认的EndPoint创建一个binding configuration.

在左侧列表中选中顶级节点services, 右侧就会列出当前的endpoint, 如图所示, 默认有两个, 其中下面那个是元数据的endpoint, 我们不去管它, 上面那个endpoint的binding configuration后面有一个”click to create” 的link, 点击, 自动创建一个binding config, 创建完成以后, 切换到security标签:

将MessageClientCredentialType改为UserName, 如上图所示.

6. 为Service创建一个behavior

如下图所示:

在左侧panel的Advanced/Service behaviors下面默认有一个Empty name的节点, 先给它起个名字, 这里我是在服务的全名后面加了个Behavior后缀, 然后点击add按钮, 增加一个serviceCredential节点. 然后配置这个新增加的service credential:

在左侧列表中选中serviceCredential下面的serviceCertificate, 对其具体的值做如上配置:

(1) FindValue改为MyTestCert, 这是我们测试证书的名字, 一会儿我们会制作一个这个名字的证书, 导入电脑中.

(2) StoreName改为TrustedPeople

(3) X509FindType改为FindBySubjectName.

7. 使用我们刚才创建的Validator类

选中serviceCredential节点, 配置一下我们的自定义验证类:

其中CustomUserNamePasswordValidatoryType属性的值是:"WcfServiceLibrary3.Validator,WcfServiceLibrary3”, 前一个WcfServiceLibrary3是命名空间名, 后一个是程序集名, 不可省略. 然后将UserNamePasswordValidationMode设成Custom.

8. 将创建的behavior与服务进行关联.

在左侧面板中选中我们创建的服务Service1, 右侧将刚刚配置好的Service1Behavior与之进行关联, 这样整个服务端的配置就完成了.

保存以后, 完成的app.config如下所示:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>

<system.web>
<compilation debug="true" />
</system.web>

<system.serviceModel>
<bindings>
<wsHttpBinding>
<binding name="NewBinding0">
<security>
<message clientCredentialType="UserName" />
</security>
</binding>
</wsHttpBinding>
</bindings>
<services>
<service behaviorConfiguration="WcfServiceLibrary3.Service1Behavior"
name="WcfServiceLibrary3.Service1">
<endpoint address="" binding="wsHttpBinding" bindingConfiguration="NewBinding0"
contract="WcfServiceLibrary3.IService1">
<identity>
<dns value="localhost" />
</identity>
</endpoint>
<endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
<host>
<baseAddresses>
<add baseAddress="http://localhost:8732/Design_Time_Addresses/WcfServiceLibrary3/Service1/" />
</baseAddresses>
</host>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name="WcfServiceLibrary3.Service1Behavior">
<serviceMetadata httpGetEnabled="true" />
<serviceDebug includeExceptionDetailInFaults="false" />
<serviceCredentials>
<serviceCertificate findValue="MyTestCert" storeName="TrustedPeople"
x509FindType="FindBySubjectName" />
<userNameAuthentication userNamePasswordValidationMode="Custom"
customUserNamePasswordValidatorType="WcfServiceLibrary3.Validator,WcfServiceLibrary3" />
</serviceCredentials>
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>

</configuration>
9. 创建证书并导入.

在开始菜单—>Microsoft Visual Studio2010—>Visual Studio Tools下面, 点击Visual Studio Command Prompt, 打开命令行窗口, 输入以下命令:

makecert -r -pe -n "CN=MyTestCert" -ss TrustedPeople -sr LocalMachine -sky exchange

10. 现在F5重新运行, 再次点击按钮1时, 抛出如下异常:

现在我们已经可以确定, 客户端再妄想匿名使用服务是不可能了, 接下来配置客户端的使用凭证.

接下来右击客户端的app.config, 继续选Edit WCF Configuration.

11, 创建endpoint behavior

在Advanced/endpoint behavior下面新建一个endpoint behavior:

然后点击Add, 新增一个clientCredential节点.

展开它的serviceCertificate节点, 选中defaultCertificate, 编辑它的属性如下图:

这几项的值和服务器端的设置是一致的.

12. 将此behavior绑定到endpoint

13. 指定dns

切换到identity标签, 将dns属性指定为我们的证书名:

至此, 客户端的配置也全部结束. 最终客户端的app.config代码为:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<behaviors>
<endpointBehaviors>
<behavior name="NewBehavior0">
<clientCredentials>
<serviceCertificate>
<defaultCertificate findValue="MyTestCert" storeLocation="LocalMachine"
storeName="TrustedPeople" x509FindType="FindBySubjectName" />
</serviceCertificate>
</clientCredentials>
</behavior>
</endpointBehaviors>
</behaviors>
<bindings>
<wsHttpBinding>
<binding name="WSHttpBinding_IService1" closeTimeout="00:01:00"
openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
bypassProxyOnLocal="false" transactionFlow="false" hostNameComparisonMode="StrongWildcard"
maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
messageEncoding="Text" textEncoding="utf-8" useDefaultWebProxy="true"
allowCookies="false">
<readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
maxBytesPerRead="4096" maxNameTableCharCount="16384" />
<reliableSession ordered="true" inactivityTimeout="00:10:00"
enabled="false" />
<security mode="Message">
<message clientCredentialType="UserName" negotiateServiceCredential="true"
algorithmSuite="Default" />
</security>
</binding>
</wsHttpBinding>
</bindings>
<client>
<endpoint address="http://localhost:8732/Design_Time_Addresses/WcfServiceLibrary3/Service1/"
behaviorConfiguration="NewBehavior0" binding="wsHttpBinding"
bindingConfiguration="WSHttpBinding_IService1" contract="ServiceReference1.IService1"
name="WSHttpBinding_IService1">
<identity>
<dns value="MyTestCert" />
</identity>
</endpoint>
</client>
</system.serviceModel>
</configuration>

14, 指定用户名和密码.

把客户端的按钮点击代码改为:

private void button1_Click(object sender, EventArgs e)
{
var ser = new ServiceReference1.Service1Client();
ser.ClientCredentials.UserName.UserName = "u";
ser.ClientCredentials.UserName.Password = "p";
MessageBox.Show(ser.GetData(0));
}

F5运行, 可以看到返回正确的结果, 而如果用户名和密码不正确, 则会抛出异常:

本文链接