博客园_首页

[WCF REST] 通过ASP.NET Output Caching实现声明式缓存

2012-02-10T00:58:00Z

ASP.NET的输出缓存（Output Caching）机制允许我们针对整个Web页面或者页面的某个部分（主要针对用户控件）最终呈现的HTML进行缓存。对于后续针对相同资源的请求，只需要直接将缓存的HTML予以回复而无须按照页面处理生命周期对每次请求进行重复处理。WCF通过操作行为AspNetCacheProfileAttribute利用ASP.NET的输出缓存提供一种针对于某个操作的声明式缓存机制。[源代码从这里下载]

一、AspNetCacheProfileAttribute

WCF对ASP.NET缓存的支持是通过AspNetCacheProfileAttribute特性来实现的。通过如下的代码我们不难看出AspNetCacheProfileAttribute是实现了IOperationBehavior接口的操作行为，我们可以直接将其应用到契约接口/类中的某个具有缓存需要的操作方法上。

   1: [AttributeUsage(AttributeTargets.Method)]

   2: public sealed class AspNetCacheProfileAttribute : Attribute, IOperationBehavior

   3: {

   4:     //其他成员

   5:     public AspNetCacheProfileAttribute(string cacheProfileName);

   6:     public string CacheProfileName { get; }

   7: }

AspNetCacheProfileAttribute构造函数参数cacheProfileName表示的CacheProfile的配置名称，目标操作按照定义在相应CacheProfile的缓存策略实施缓存。CacheProfile配置在<system.web>/<caching>/<outputCacheSettings>/<outputCacheProfiles>节点下。

   1: <configuration>

   2:   <connectionStrings>

   3:     <add name="localDb"

   4:          connectionString="Server=.; Database=TestDb; Uid=sa; Pwd=password"

   5:          providerName="System.Data.SqlClient"/>

   6:   </connectionStrings>

   7:   <system.web>

   8:     <caching>

   9:       <outputCacheSettings>

  10:         <outputCacheProfiles>

  11:           <add name="default"

  12:                duration="60"

  13:                varyByParam="none"

  14:                sqlDependency="TestDb: TestTable"/>

  15:         </outputCacheProfiles>

  16:       </outputCacheSettings>

  17:       <sqlCacheDependency>

  18:         <databases>

  19:           <add name="TestDb" connectionStringName="localDb"/>

  20:         </databases>

  21:       </sqlCacheDependency>

  22:     </caching>

  23:   </system.web>

  24: </configuration>

在如上所示的配置片断中，我们定义了一个名称为default的CacheProfile。代表缓存时间的duration属性被设置为60，意味着缓存项在被存储之后1分钟之后实失效；属性varyByParam被设置为none表示缓存项与请求的查询字符串无关。此外，该CacheProfile还设置针对某个本地数据库中的TestTable表的SQL依赖（SQL Dependency）。关于CacheProfile的配置属于ASP.NET的范畴，在这里我们不会作过多的讨论。

既然是采用ASP.NET输出缓存，WCF服务自然需要采用IIS寄宿并采用ASP.NET 兼容模式。值得一提的是，基于AspNetCacheProfileAttribute的输出缓存仅仅针对HTTP-GET。

二、实例演示：创建采用输出缓存的服务

接下来我们通过一个简单的实例来演示如何通过操作行为对某个操作的返回值实施缓存，为此我们创建一个用于返回当前时间的服务。如下所示的是作为服务契约的ITime接口的定义，AspNetCacheProfileAttribute特性被应用到了用于返回当前时间的操作方法GetCurrentTime上。

   1: using System;

   2: using System.ServiceModel;

   3: using System.ServiceModel.Web;

   4: namespace Artech.WcfServices.Service.Interface

   5: {

   6:     [ServiceContract(Namespace = "http://www.artech.com/")]

   7:     public interface ITime

   8:     {

   9:         [WebGet(UriTemplate = "/current")]

  10:         [AspNetCacheProfile("default")]

  11:         DateTime GetCurrentTime();

  12:     }

  13: }

实现了契约接口ITime的服务类型TimeService定义如下。我们将AspNetCompatibilityRequirementsAttribute特性应用在服务类型上并将RequirementsMode属性设置为Allowed以提供对ASP.NET兼容模式的支持。

   1: using System;

   2: using System.ServiceModel.Activation;

   3: using Artech.WcfServices.Service.Interface;

   4: namespace Artech.WcfServices.Service

   5: {

   6:     [AspNetCompatibilityRequirements(

   7:      RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

   8:     public class TimeService : ITime

   9:     {

  10:         public DateTime GetCurrentTime()

  11:         {

  12:             return DateTime.Now;

  13:         }

  14:     }

  15: }

在一个Web项目中我们为通过IIS寄宿的服务TimeService添加一个对应的.svc文件（TimeService.svc），如下所示的是<%@ServiceHost%>指令的定义。表示ServiceHostFactory类型的指令属性Factory被设置为System.ServiceModel.Activation.WebServiceHostFactory.

   1: <%@ ServiceHost Service="Artech.WcfServices.Service.TimeService" Factory="System.ServiceModel.Activation.WebServiceHostFactory"%>

我们在作为服务宿主的Web项目下添加一个配置文件（Web.config）并定义如下的配置。除了服务寄宿的基本配置外，我们将<system.serviceModel>/<serviceHostingEnvironment >配置节的aspNetCompatibilityEnabled属性设置为True以开启ASP.NET兼容模式。应用在操作方法GetCurrentTime上的AspNetCacheProfileAttribute特性中指定的名称为default的CacheProfile定义在该配置中，duration和varyByParam分别被设置为60和none。

   1: <configuration>

   2:     <system.serviceModel>

   3:         <services>

   4:             <service name="Artech.WcfServices.Service.TimeService">

   5:                 <endpoint binding="webHttpBinding"

   6:                           contract="Artech.WcfServices.Service.Interface.ITime"/>

   7:             </service>

   8:         </services>

   9:       <serviceHostingEnvironment aspNetCompatibilityEnabled="true" />

  10:     </system.serviceModel>

  11:   <system.web>

  12:     <caching>

  13:       <outputCacheSettings>

  14:         <outputCacheProfiles>

  15:           <add name="default" duration="60" varyByParam="none"/>

  16:         </outputCacheProfiles>

  17:       </outputCacheSettings>

  18:     </caching>

  19:   </system.web>

  20: </configuration>

作为客户端的控制台程序在进行了相应配置之后通过如下的代码进行服务的调用。在这段代码中，我们通过创建的服务代理进行了5次服务调用，并将获取的时间打印出来。每次服务的时间间隔为1秒。

   1: using (ChannelFactory<ITime> channelFactory =  new ChannelFactory<ITime>("timeService"))

   2: {

   3:     ITime proxy = channelFactory.CreateChannel();

   4:     for (int i = 0; i < 5; i++)

   5:     {

   6:         Console.WriteLine(proxy.GetCurrentTime().ToLongTimeString());

   7:         Thread.Sleep(1000);

   8:     }

   9: }

客户端代码执行之后会在控制台上输出如下的结果。由于服务端通过ASP.NET的输出缓存对第一次执行GetCurrentTime操作的结果进行了缓存，所以客户端返回的时间都是相同的。

   1: 4:48:43 PM

   2: 4:48:43 PM

   3: 4:48:43 PM

   4: 4:48:43 PM

   5: 4:48:43 PM

三、 AspNetCacheProfileAttribute是如何实现输出缓存的？

既然我们采用ASP.NET兼容模式来寄宿服务，意味着我们调用某个服务与访问某个页面没有本质的区别，所以基于Web页面的输出缓存能够应用于基于某个服务操作的调用就不足为奇了。现在有这么一个问题：通过AspNetCacheProfileAttribute特性指定CacheProfile是如何生效的？

如果对ASP.NET具有一定的了解，应该知道可以通过当前HttpResponse（HttpContext.Current.Response）的Cache属性表示的HttpCachePolicy对象来控制当前输出缓存的基本策略。实际上AspNetCacheProfileAttribute就是通过这种方式将定义在指定CacheProfile的缓存策略应用到针对当前操作的调用上的。

具体来说，AspNetCacheProfileAttribute针对输出缓存策略的控制是通过一个实现了接口IParameterInspector的自定义参数检验器实现的，这是一个名称为CachingParameterInspector的内部类型。操作行为AspNetCacheProfileAttribute通过实现的ApplyDispatchBehavior方法将针对某个CacheProfile创建的CachingParameterInspector对象添加到当前分发操作（DispatchOperation）的参数检验器列表中。

   1: internal class CachingParameterInspector : IParameterInspector

   2: {

   3:     public CachingParameterInspector(string cacheProfileName);

   4:     public object BeforeCall(string operationName, object[] inputshens);

   5:     public void AfterCall(string operationName, object[] outputs, object returnValue, object correlationState)

   6:     {

   7:         //将指定CacheProfile的输出缓存策略应用到当前HttpResponse

   8:     }

   9: }

如上面的代码片断所示，当AfterCall方法被执行的之后，在构造函数中指定的CacheProfile定义的输出缓存策略应用到当前HttpResponse。而AfterCall会在操作执行之后，回复消息序列化之前被执行。

本文链接

深入理解JavaScript系列（20）：《你真懂JavaScript吗？》答案详解

2012-02-10T00:54:00Z

介绍

昨天发的《大叔手记（19）：你真懂JavaScript吗？》里面的5个题目，有很多回答，发现强人还是很多的，很多人都全部答对了。

今天我们来对这5个题目详细分析一下，希望对大家有所帮助。

注：

问题来着大名鼎鼎的前端架构师Baranovskiy的帖子《So, you think you know JavaScript?》。
答案也是来着大名鼎鼎的JS牛人Nicholas C. Zakas的帖子《Answering Baranovskiy’s JavaScript quiz》——《JavaScript高级程序设计》一书的原作者
(但题目2的解释貌似有点问题）

OK，我们先看第一题

题目1

if (!("a" in window)) {
    var a = 1;
}
alert(a);

代码看起来是想说：如果window不包含属性a，就声明一个变量a，然后赋值为1。

你可能认为alert出来的结果是1，然后实际结果是“undefined”。要了解为什么，我们需要知道JavaScript里的3个概念。

首先，所有的全局变量都是window的属性，语句 var a = 1;等价于window.a = 1; 你可以用如下方式来检测全局变量是否声明：

"变量名称" in window

第二，所有的变量声明都在范围作用域的顶部，看一下相似的例子：

alert("a" in window);
var a;

此时，尽管声明是在alert之后，alert弹出的依然是true，这是因为JavaScript引擎首先会扫墓所有的变量声明，然后将这些变量声明移动到顶部，最终的代码效果是这样的：

var a;
alert("a" in window);

这样看起来就很容易解释为什么alert结果是true了。

第三，你需要理解该题目的意思是，变量声明被提前了，但变量赋值没有，因为这行代码包括了变量声明和变量赋值。

你可以将语句拆分为如下代码：

var a;    //声明
a = 1;    //初始化赋值

当变量声明和赋值在一起用的时候，JavaScript引擎会自动将它分为两部以便将变量声明提前，不将赋值的步骤提前是因为他有可能影响代码执行出不可预期的结果。

所以，知道了这些概念以后，重新回头看一下题目的代码，其实就等价于：

var a;
if (!("a" in window)) {
    a = 1;
}
alert(a);

这样，题目的意思就非常清楚了：首先声明a，然后判断a是否在存在，如果不存在就赋值为1，很明显a永远在window里存在，这个赋值语句永远不会执行，所以结果是undefined。

大叔注：提前这个词语显得有点迷惑了，其实就是执行上下文的关系，因为执行上下文分2个阶段：进入执行上下文和执行代码，在进入执行上下文的时候，创建变量对象VO里已经有了：函数的所有形参、所有的函数声明、所有的变量声明

VO(global) = {
    a: undefined
}

这个时候a已经有了；

然后执行代码的时候才开始走if语句，详细信息请查看《深入理解JavaScript系列（12）：变量对象（Variable Object）》中的处理上下文代码的2个阶段小节。

大叔注：相信很多人都是认为a在里面不可访问，结果才是undefined的吧，其实是已经有了，只不过初始值是undefined，而不是不可访问。

题目2

var a = 1,
    b = function a(x) {
        x && a(--x);
    };
alert(a);

这个题目看起来比实际复杂，alert的结果是1；这里依然有3个重要的概念需要我们知道。

首先，在题目1里我们知道了变量声明在进入执行上下文就完成了；第二个概念就是函数声明也是提前的，所有的函数声明都在执行代码之前都已经完成了声明，和变

量声明一样。澄清一下，函数声明是如下这样的代码：

function functionName(arg1, arg2){
    //函数体
}

如下不是函数，而是函数表达式，相当于变量赋值：

var functionName = function(arg1, arg2){
    //函数体
};

澄清一下，函数表达式没有提前，就相当于平时的变量赋值。

第三需要知道的是，函数声明会覆盖变量声明，但不会覆盖变量赋值，为了解释这个，我们来看一个例子：

function value(){
    return 1;
}
var value;
alert(typeof value);    //"function"

尽快变量声明在下面定义，但是变量value依然是function，也就是说这种情况下，函数声明的优先级高于变量声明的优先级，但如果该变量value赋值了，那结果就完全不一样了：

function value(){
    return 1;
}
var value = 1;
alert(typeof value);    //"number"

该value赋值以后，变量赋值初始化就覆盖了函数声明。

重新回到题目，这个函数其实是一个有名函数表达式，函数表达式不像函数声明一样可以覆盖变量声明，但你可以注意到，变量b是包含了该函数表达式，而该函数表达式的名字是a；不同的浏览器对a这个名词处理有点不一样，在IE里，会将a认为函数声明，所以它被变量初始化覆盖了，就是说如果调用a(--x)的话就会出错，而其它浏览器在允许在函数内部调用a(--x)，因为这时候a在函数外面依然是数字。基本上，IE里调用b(2)的时候会出错，但其它浏览器则返回undefined。

理解上述内容之后，该题目换成一个更准确和更容易理解的代码应该像这样：

var a = 1,
    b = function(x) {
        x && b(--x);
    };
alert(a);

这样的话，就很清晰地知道为什么alert的总是1了，详细内容请参考《深入理解JavaScript系列（2）：揭秘命名函数表达式》中的内容。

大叔注：安装ECMAScript规范，作者对函数声明覆盖变量声明的解释其实不准确的，正确的理解应该是如下：

进入执行上下文：这里出现了名字一样的情况，一个是函数申明，一个是变量申明。那么，根据深入理解JavaScript系列（12）：变量对象（Variable Object）介绍的，填充VO的顺序是: 函数的形参 -> 函数申明 -> 变量申明。
上述例子中，变量a在函数a后面，那么，变量a遇到函数a怎么办呢？还是根据变量对象中介绍的，当变量申明遇到VO中已经有同名的时候，不会影响已经存在的属性。而函数表达式不会影响VO的内容，所以b只有在执行的时候才会触发里面的内容。

题目3

function a(x) {
    return x * 2;
}
var a;
alert(a);

这个题目就是题目2里的大叔加的注释了，也就是函数声明和变量声明的关系和影响，遇到同名的函数声明，VO不会重新定义，所以这时候全局的VO应该是如下这样的：

VO(global) = {
    a: 引用了函数声明“a”
}

而执行a的时候，相应地就弹出了函数a的内容了。

题目4

function b(x, y, a) {
    arguments[2] = 10;
    alert(a);
}
b(1, 2, 3);

关于这个题目，NC搬出了262-3的规范出来解释，其实从《深入理解JavaScript系列（12）：变量对象（Variable Object）》中的函数上下文中的变量对象一节就可以清楚地知道，活动对象是在进入函数上下文时刻被创建的，它通过函数的arguments属性初始化。arguments属性的值是Arguments对象：

AO = {
  arguments: <ArgO>
};

Arguments对象是活动对象的一个属性，它包括如下属性：

callee — 指向当前函数的引用
length — 真正传递的参数个数
properties-indexes (字符串类型的整数) 属性的值就是函数的参数值(按参数列表从左到右排列)。 properties-indexes内部元素的个数等于arguments.length. properties-indexes 的值和实际传递进来的参数之间是共享的。

这个共享其实不是真正的共享一个内存地址，而是2个不同的内存地址，使用JavaScript引擎来保证2个值是随时一样的，当然这也有一个前提，那就是这个索引值要小于你传入的参数个数，也就是说如果你只传入2个参数，而还继续使用arguments[2]赋值的话，就会不一致，例如：

function b(x, y, a) {
    arguments[2] = 10;
    alert(a);
}
b(1, 2);

这时候因为没传递第三个参数a，所以赋值10以后，alert(a)的结果依然是undefined，而不是10，但如下代码弹出的结果依然是10，因为和a没有关系。

function b(x, y, a) {
    arguments[2] = 10;
    alert(arguments[2]);
}
b(1, 2);

题目5

function a() {
    alert(this);
}
a.call(null);

这个题目可以说是最简单的，也是最诡异的，因为如果没学到它的定义的话，打死也不会知道结果的，关于这个题目，我们先来了解2个概念。

首先，就是this值是如何定义的，当一个方法在对象上调用的时候，this就指向到了该对象上，例如：

var object = {
    method: function() {
        alert(this === object);    //true
    }
}
object.method();

上面的代码，调用method()的时候this被指向到调用它的object对象上，但在全局作用域里，this是等价于window（浏览器中，非浏览器里等价于global），在如果一个function的定义不是属于一个对象属性的时候（也就是单独定义的函数），函数内部的this也是等价于window的，例如：

function method() {
    alert(this === window);    //true
}
method();

了解了上述概念之后，我们再来了解一下call()是做什么的，call方法作为一个function执行代表该方法可以让另外一个对象作为调用者来调用，call方法的第一个参数是对象调用者，随后的其它参数是要传给调用method的参数（如果声明了的话），例如：

function method() {
    alert(this === window);
}
method();    //true
method.call(document);   //false

第一个依然是true没什么好说的，第二个传入的调用对象是document，自然不会等于window，所以弹出了false。

另外，根据ECMAScript262规范规定：如果第一个参数传入的对象调用者是null或者undefined的话，call方法将把全局对象（也就是window）作为this的值。所以，不管你什么时候传入null，其this都是全局对象window，所以该题目可以理解成如下代码：

function a() {
    alert(this);
}
a.call(window);

所以弹出的结果是[object Window]就很容易理解了。

总结

这5个题目虽然貌似有点偏，但实际上考察的依然是基本概念，只有熟知了这些基本概念才能写出高质量代码。

关于JavaScript的基本核心内容和理解基本上在该系列就到此为止了，接下来的章节除了把五大原则剩余的2篇补全依然，会再加两篇关于DOM的文章，然后就开始转向整理关于JavaScript模式与设计模式相关的文章了（大概10篇左右），随后再会花几个章节来一个实战系列。

更多题目

如果大家有兴趣，可以继续研究下面的一些题目，详细通过这些题目也可以再次加深对JavaScript基础核心特性的理解。

大叔注：这些题目也是来自出这5个题目的人，当然如果你能答对4个及以上并且想拿高工资的话，请联系我。

找出数字数组中最大的元素（使用Match.max函数）
转化一个数字数组为function数组（每个function都弹出相应的数字）
给object数组进行排序（排序条件是每个元素对象的属性个数）
利用JavaScript打印出Fibonacci数（不使用全局变量）
实现如下语法的功能：var a = (5).plus(3).minus(6); //2
实现如下语法的功能：var a = add(2)(3)(4); //9

同步与推荐

本文已同步至目录索引：深入理解JavaScript系列

深入理解JavaScript系列文章，包括了原创，翻译，转载等各类型的文章，如果对你有用，请推荐支持一把，给大叔写作的动力。

本文链接

Windows下创建XUL应用程序

2012-02-10T00:45:00Z

一、基本概念

XUL 是一个Mozilla使用XML来描述用户界面的一种技术，使用XUL你可以快速的创建出跨平台，基于因特网的应用程序。

XULRunner是一个由Mozilla基金会开发运行时环境，用来为XUL和XPCOM应用程序提供统一的后端运行环境。所有基于XUL的应用程序都是运行在XULRunner之上的，比如我们比较常用的Firefox和Thunderbird。

Gecko是套开放原始码的、以C++编写的网页排版引擎，目前为Mozilla家族网页浏览器以及Netscape 6以后版本浏览器所使用，XULRunner使用的也是它。

二、搭建开发环境

1、XULRunner为XUL应用程序提供了后端运行环境，下载XULRunner SDK，由于XULRunner自带Gecko引擎，因此不必再单独下载。

本人下载的是XULRunner sdk 2.0 for windows版本，下面的开发主要以XULRunner sdk 2.0 for windows为主，如果下载的是XULRunner2.0以前的版本则下面的内容有的则需要修改。

2、配置环境变量，这个可选只是为了方便，解压XULRunner sdk 2.0，添加xulrunner.exe所在的目录到环境变量，如：D:\xulrunner2.0\bin;

三、手工创建XUL应用程序

1、创建XUL应用程序所需目录及文件，结构如下:

-HelloXUL
           application.ini
           chrome.manifest
           -defaults
               -preferences
                    prefs.js
           -chrome
               -content
                    HelloXUL.xul

2、编辑application.ini

application.ini中包含此应用程序的基本信息，Gecko的版本信息，也是应用程序启动的入口;HelloXUL的信息如下:

[App]
     Name=HelloXUL
     ID=lintclr@126.com 
     Version=1.0.0.0
     BuildID=20120204
     Vendor=
     [Gecko]
     MinVersion=1.8
     MaxVersion=2.0.0.*
     [XRE]

3、编辑chrome.manifest

chrome.manifest包含XUL应用程序的组织结构;HelloXUL的信息如下：

content HelloXUL chrome/content/

具体其他选项参照：https://developer.mozilla.org/en/Chrome_Registration

4、编辑prefs.js

此文件主要包括应用程序的配置信息;HelloXUL配置如下：

pref("toolkit.defaultChromeURI", "chrome://HelloXUL/content/HelloXUL.xul");

/* debugging prefs */
pref("browser.dom.window.dump.enabled", true);
pref("javascript.options.showInConsole", true);
pref("javascript.options.strict", true);
pref("nglayout.debug.disable_xul_cache", true);
pref("nglayout.debug.disable_xul_fastload", true);

/* added to allow <label  ... /> to work */
pref("network.protocol-handler.expose.http", false);
pref("network.protocol-handler.warn-external.http", false);

5、编辑HelloXUL.xul

以下代码创建一个窗口，一个按钮，点击按钮弹出提示框，显示HelloXUL。

<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" style="width: 500px; height: 300px;">
      <hbox>
            <button label="HelloXUL" oncommand="alert('HelloXUL')"/>
      </hbox>
</window>

6、运行应用程序

进入应用程序主目录即HelloXUL目录，输入：xulrunner application.ini，然后回车，第一个应用程序成功运行。

四、使用IDE工具创建XUL应用程序

1、下载最新版XUL Explorer工具

2、双击安装程序,按照步骤依次安装，安装成功后运行XUL Explorer，按照以下步骤创建应用程序:

注：由于我们XULRunner版本为2.0故，此处最大版本改为2.0.0.*;

点击Finish完成。

3、进入创建应用程序目录可以看到和我们手工创建的应用程序结构一样，用上面一样的方法运行，程序成功运行。

4、如果创建时发生"0x80004002 (NS_NOINTERFACE)"错误进行以下操作：

(1)将 XUL Explorer 中 chrome 目录下的 en-US.jar 解压，目录名为“en-US”，其中的目录层次要和en-US.jar中的完全一致。

(2)修改 en-US.manifest 文件，将 locale explorer en-US jar:en-US.jar!/ 改为 locale explorer en-US file:en-US/

五、应用程序实现双击运行

1、在应用程序根目录创建xulrunner目录，将xulrunner sdk中bin目录里的内容复制到该目录。

2、将xulrunner目录中的xulrunner-stub.exe和mozcrt19.dll复制到应用程序的根目录，双击xulrunner-stub.exe应用程序成功运行。

本文链接

高效程序员秘籍（10）：聚合个人全部邮箱

2012-02-10T00:33:00Z

对于有很多个邮箱的人来说，查看是否有新邮件是件挺烦琐的事情，尤其是拥有各种不同网站的邮箱，需要分别登录各个邮箱进行。如果有可以集中查看所有邮箱中新邮件的方法就方便多了，下面就向大家介绍两种方法。
第一种方法是挑选一个邮箱作为聚合邮箱，用来接收其他邮箱的新邮件，也可以在该邮箱中以其他邮箱作为发送地址。建议把Gmail邮箱作为聚合邮箱，或者其他功能比较强大的Web邮箱，使用Web邮箱的好处是随时随地都可以收发邮件，只要有一个包含浏览器的终端设备即可。把新邮件自动转发到聚合邮箱的过程很简单，只需要在邮箱设置的自动转发选项中输入聚合邮箱即可，随后聚合邮箱会收到一封自动转发确认邮件，点击邮件内容中提供的验证链接完成验证，到此为止，一个邮箱的新邮件自动转发到聚合邮箱就完成了。类似Forxmail、Outlook等邮箱都有新邮件到达的通知和提示功能，其实基于Web的邮箱也能做到，不过需要做一些额外的工作。大部分浏览器都有新邮件提示器插件，例如火狐中有WebMail Notifier，360浏览器中有邮件app，但是在聚合邮箱中想用其他邮箱帐号回复某个邮件就只能登录该邮箱了，不过有的邮箱客户端支持多个邮件发送地址，比如Gmail支持多个邮件发送地址，在发邮件时可以选择用哪个邮箱发送。在Gmail中增加邮件发送账户的方法：进入邮箱设置，选择“账户和导入”选项卡，点击“用这个地址发送邮件”右边的超链接，即“添加您拥有的其他电子邮件地址”，浏览器会弹出一个对话框，在其中的输入框中填写要作为发送地址的邮箱，按照提示继续即可，以后在聚合邮箱中收到来自该邮箱的新邮件，回复邮件时的发送地址默认就是该邮箱。
第二种方法是使用Pop peeper。Pop peeper是一款小巧的邮件检测利器，支持各种各样的提醒方式，可绑定任意多个邮箱帐号，可以把它作为一款简单实用的邮件客户端，也可以和已有的邮件客户端（如Outlook）关联。主界面如下图所示：

首先要做的就是把帐号导入Pop peeper，它支持自动添加，单击左下角的添加按钮，可以选择导入帐号或者添加单个帐号，当选择导入帐号后POP Peeper程序会自动将本机中的OutLook中或者其他邮件客户端中的已有帐号全部显示出来，在需要导入的邮件帐号前面打上勾号，然后单击“完成”按钮，然后分别输入对应各个帐号的邮件访问密码，最后单击密码输入框中的更新按钮，就能将被选中的邮件帐号全部添加到POP Peeper程序中了。如果选择手动添加帐号的话，在随后弹出的向导窗口中，依次输入电子邮件地址、帐号名称、登录邮件服务器的名称与密码、邮件收发服务器的IP地址等信息，最后单击“完成”按钮，结束帐号创建工作。Gmail帐号的导入可能需要额外的工作，具体可参见官方网站的说明：http://www.poppeeper.com/faq.php。以下是Pop peeper所支持的提醒方式：
1、语音提醒，可以自定义语音。
2、托盘图标通知，显示每个帐户的新邮件数量。
3、闪烁的滚动锁定指示灯
4、Windows弹出窗口中显示收到新电子邮件的帐户
5、气球提示显示收到的最后一封电子邮件消息的主题和发件人
6、自动打开Pop peeper或启动电子邮件客户端
7、自动朗读收到的邮件（需要下载插件）
8、启动屏幕保护程序，在其中显示收到新邮件的账户和邮件数量（需要下载插件）
9、不间断地语音提示，直到得到用户的确认（需要下载插件）

使用邮箱聚合的方式后，基本上就只需要登录聚合邮箱进行操作了，可以节约不少时间，园友们不妨尝试一下。

本文链接

[Architecture Pattern] Singleton Pool 模式

2012-02-10T00:04:00Z

动机 :

在开发与数据库沟通的系统时，因为建立数据库联机是比较昂贵的。
所以ADO.NET在背后，帮开发人员实做了 ConnectionPool的机制。
将系统内建立的数据库联机做快取，
当系统要使用时就直接使用快取联机，避免了每次都建立新数据库联机的花费。

实际上在使用ADO.NET时，开发人员对于背后的ConnectionPool机制其实是无感的。
要让开发人员无感，可是又能完成快取的功能，这真的要花一点工夫去设计。

本文介绍一个『Singleton Pool模式』。
定义对象之间的职责跟互动，用来建置类似ConnectionPool功能的对象池功能，并且提供开发人员无感的使用界面。
为自己做个纪录，也希望能帮助到有需要的开发人员。

结构 :

『Singleton Pool模式』是Flyweight Pattern的延伸，有兴趣的开发人员可以找相关文章做参考。
模式的结构如下：

主要的参与者有：
NativeConnection
-实际提供功能的对象。

ReferenceRecord
-快取NativeConnection，并且纪录有多少客户端正在使用中。

ConnectionPool
-建立ReferenceRecord用来快取对象及记录使用者。
-当有人要使用NativeConnection，可是系统内没有快取的时候，建构快取。
-当有人要使用NativeConnection，可是系统内已有快取的时候，回传快取。
-当没有人使用NativeConnection，可是系统内已有快取的时候，解构快取。

Connection
-合成NativeConnection功能提供外部使用。
-将NativeConnection的建构、解构，交由ConnectionPool去处理。

透过下面的图片说明，可以了解相关对象之间的互动流程。

实做 :

范列下载 :

范例的程序代码较多，实做说明请参照范例程序内容。
SingletonPoolSample点此下载

范列实做 :

范例内容实做一个模拟的ConnectionPool，它会快取实际联机到数据库的对象，并且会将内部执行讯息打印到Console上。
透过这个范例，可以清楚的了解如何实做以及执行效果。

首先在项目里实做一个虚拟的NativeConnection，用来仿真实际联机到数据库的功能以及将执行讯息打印到Console上。

public class NativeConnection : IDisposable
{
    // Fields
    private readonly string _connectionString = null;


    // Constructor
    public NativeConnection(string connectionString)
    {
        #region Require

        if (string.IsNullOrEmpty(connectionString) == true) throw new ArgumentNullException();

        #endregion
        _connectionString = connectionString;
        Console.WriteLine(string.Format("Connect to database.[{0}]", _connectionString));
    }

    public void Dispose()
    {
        Console.WriteLine(string.Format("Disconnection to database.[{0}]", _connectionString));
    }


    // Methods  
    public void Query()
    {
        Console.WriteLine(string.Format("Query.[{0}]", _connectionString));
    }
}

再来建立ReferenceRecord，用来快取NativeConnection，并且纪录谁使用了NativeConnection。

internal sealed class ReferenceRecord<TReferenceKey, TReferenceItem>
{
    // Fields
    private readonly List<Guid> _consumerIdList = new List<Guid>();


    // Constructor
    public ReferenceRecord(TReferenceKey referenceKey, TReferenceItem referenceItem)
    {
        #region Require

        if (referenceKey == null) throw new ArgumentNullException();
        if (referenceItem == null) throw new ArgumentNullException();

        #endregion
        this.ReferenceKey = referenceKey;
        this.ReferenceItem = referenceItem;
    }


    // Properties
    public TReferenceKey ReferenceKey { get; private set; }

    public TReferenceItem ReferenceItem { get; private set; }


    // Methods   
    public void Register(Guid consumerId)
    {
        #region Require

        if (consumerId == Guid.Empty) throw new ArgumentNullException();

        #endregion
        if (_consumerIdList.Contains(consumerId) == false)
        {
            _consumerIdList.Add(consumerId);
        }
    }

    public void Unregister(Guid consumerId)
    {
        #region Require

        if (consumerId == Guid.Empty) throw new ArgumentNullException();

        #endregion
        if (_consumerIdList.Contains(consumerId) == true)
        {
            _consumerIdList.Remove(consumerId);
        }
    }

    public bool NoConsumerRegistered()
    {
        if (_consumerIdList.Count <= 0)
        {
            return true;
        }
        return false;
    }
}

接着实做ConnectionPool，用来将整个『Singleton Pool模式』的流程做封装。

public abstract class ReferencePool<TReferenceKey, TReferenceItem>
{
    // Fields
    private readonly List<ReferenceRecord<TReferenceKey, TReferenceItem>> _referenceRecordCollection = new List<ReferenceRecord<TReferenceKey, TReferenceItem>>();


    // Methods   
    public virtual TReferenceItem Create(Guid consumerId, TReferenceKey referenceKey)
    {
        #region Require

        if (consumerId == Guid.Empty) throw new ArgumentNullException();
        if (referenceKey == null) throw new ArgumentNullException();

        #endregion     
      
        // Return Existing ReferenceItem
        foreach (ReferenceRecord<TReferenceKey, TReferenceItem> referenceRecord in _referenceRecordCollection)
        {
            if (this.CompareReferenceKey(referenceKey, referenceRecord.ReferenceKey) == true)
            {
                referenceRecord.Register(consumerId);
                return referenceRecord.ReferenceItem;
            }                
        }

        // Return New  ReferenceItem
        TReferenceItem referenceItem = this.CreateReferenceItem(referenceKey);
        if (referenceItem == null) throw new InvalidOperationException("CreateReferenceItem failed.");

        ReferenceRecord<TReferenceKey, TReferenceItem> newReferenceRecord = new ReferenceRecord<TReferenceKey, TReferenceItem>(referenceKey, referenceItem);            
        _referenceRecordCollection.Add(newReferenceRecord);
        newReferenceRecord.Register(consumerId);

        return referenceItem;
    }

    public virtual void Release(Guid consumerId, TReferenceKey referenceKey)
    {
        #region Require

        if (consumerId == Guid.Empty) throw new ArgumentNullException();
        if (referenceKey == null) throw new ArgumentNullException();

        #endregion

        // Release Existing ReferenceItem
        ReferenceRecord<TReferenceKey, TReferenceItem> existingReferenceRecord = null;
        foreach (ReferenceRecord<TReferenceKey, TReferenceItem> referenceRecord in _referenceRecordCollection)
        {
            if (this.CompareReferenceKey(referenceKey, referenceRecord.ReferenceKey) == true)
            {
                existingReferenceRecord = referenceRecord;
                break;
            }
        }

        if (existingReferenceRecord != null)
        {
            existingReferenceRecord.Unregister(consumerId);
            if (existingReferenceRecord.NoConsumerRegistered() == true)
            {
                _referenceRecordCollection.Remove(existingReferenceRecord);
                this.ReleaseReferenceItem(existingReferenceRecord.ReferenceItem);                    
            }
        }
    }


    protected abstract TReferenceItem CreateReferenceItem(TReferenceKey referenceKey);

    protected abstract void ReleaseReferenceItem(TReferenceItem referenceItem);

    protected abstract bool CompareReferenceKey(TReferenceKey referenceKeyA, TReferenceKey referenceKeyB);
}

public class ConnectionPool : ReferencePool<string, NativeConnection>
{
    // Methods  
    protected override NativeConnection CreateReferenceItem(string connectionString)
    {
        #region Require

        if (string.IsNullOrEmpty(connectionString) == true) throw new ArgumentNullException();

        #endregion
        return new NativeConnection(connectionString);
    }

    protected override void ReleaseReferenceItem(NativeConnection connection)
    {
        #region Require

        if (connection == null) throw new ArgumentNullException();

        #endregion     
        connection.Dispose();
    }

    protected override bool CompareReferenceKey(string connectionStringA, string connectionStringB)
    {
        #region Require

        if (string.IsNullOrEmpty(connectionStringA) == true) throw new ArgumentNullException();
        if (string.IsNullOrEmpty(connectionStringB) == true) throw new ArgumentNullException();

        #endregion
        return connectionStringA == connectionStringB;
    }
}

剩下就是Connection了，这个对象合成NativeConnection对象提供外部使用。并且在建构、解构的函式内，调用Singleton的ConnectionPool，来完成『Singleton Pool模式』的功能。

public class Connection : IDisposable
{
    // Singleton
    private static ConnectionPool _poolInstance = null;

    private static ConnectionPool PoolInstance
    {
        get
        {
            if (_poolInstance == null)
            {
                _poolInstance = new ConnectionPool();
            }
            return _poolInstance;
        }
    }


    // Fields
    private readonly Guid _consumerId = Guid.Empty;

    private readonly string _connectionString = null;

    private readonly ConnectionPool _connectionPool = null;

    private readonly NativeConnection _nativeConnection = null;        


    // Constructor
    public Connection(string connectionString) : this(connectionString, Connection.PoolInstance) { }

    public Connection(string connectionString, ConnectionPool connectionPool)
    {
        #region Require

        if (string.IsNullOrEmpty(connectionString) == true) throw new ArgumentNullException();
        if (connectionPool == null) throw new ArgumentNullException();

        #endregion

        // Arguments
        _consumerId = Guid.NewGuid();
        _connectionString = connectionString;
        _connectionPool = connectionPool;

        // Create
        _nativeConnection = _connectionPool.Create(_consumerId, _connectionString);
        if (_nativeConnection == null) throw new InvalidOperationException("Create NativeConnection failed.");
    }

    public void Dispose()
    {
        // Release
        _connectionPool.Release(_consumerId, _connectionString);
    }


    // Methods  
    public void Query()
    {
        // Query
        _nativeConnection.Query();
    }        
}

最后我们加上测试的程序以及执行的结果。
由程序代码可以看到，虽然建立了三个Connection来使用，
可是因为对象套用『Singleton Pool模式』的缘故，NativeConnection的建构、解构是依照ConnectionString的数量(两个)来执行。

class Program
{
    static void Main(string[] args)
    {
        Connection connectionA = new Connection("XXX Database");
        Connection connectionB = new Connection("YYY Database");
        Connection connectionC = new Connection("XXX Database");

        connectionA.Query();
        connectionB.Query();
        connectionC.Query();

        connectionA.Dispose();
        connectionB.Dispose();
        connectionC.Dispose();

        Console.ReadLine();
    }
}

后记 :

如果在一些不大适合使用Singleton的系统内，也可以采用下列的模式。
增加一个ConnectionManager，来套用『Singleton Pool模式』的功能。

public class ConnectionManager
{
    // Fields
    private readonly ConnectionPool _connectionPool = new ConnectionPool();


    // Methods   
    public Connection Create(string connectionString)
    {
        #region Require

        if (string.IsNullOrEmpty(connectionString) == true) throw new ArgumentNullException();

        #endregion            
        return new Connection(connectionString, _connectionPool);
    }
}

class Program
{
    static void Main(string[] args)
    {
        ConnectionManager connectionManager = new ConnectionManager();

        Connection connectionA = connectionManager.Create("XXX Database");
        Connection connectionB = connectionManager.Create("YYY Database");
        Connection connectionC = connectionManager.Create("XXX Database");

        connectionA.Query();
        connectionB.Query();
        connectionC.Query();

        connectionA.Dispose();
        connectionB.Dispose();
        connectionC.Dispose();

        Console.ReadLine();
    }
}

本文链接

淘宝API开发系列---淘宝API的测试及使用2

2012-02-09T23:36:00Z

继续前面一篇随笔《淘宝API开发系列---淘宝API的测试及使用》，来继续介绍淘宝API的具体代码开发部分，上篇主要是介绍淘宝SDK开发的一些流程及必备的信息，以及掌握如何学会利用API文档、淘宝API测试工具来获取我们所需的数据，其中我一般倾向于获取Json数据，然后进行分析，其中Json数据可以通过JsonView工具（http://jsonviewer.codeplex.com/）进行格式化显示，方便我们了解和区分各个属性的信息。另外淘宝的SDK里面，封装了很多对象，我们通过数据就可以获取到相关的信息了，不过注意的就是，我们每个接口调用，都要传入Fields的属性，如果我们没有指定相应的属性字段，那么接口返回的数据，就没有这项的，淘宝SDK的对象属性就会为空。

通过以上的工具，我们就能可视化属性的信息了，对接口数据的理解就更加清晰，首先我们来看看我测试例子的运行效果如下所示。

其中上面例子的代码如下所示。

  private void TestUserGet()
        {
            //单独用户的信息
            Console.WriteLine("单独用户的信息");
            UserGetRequest req = new UserGetRequest(); //实例化具体API对应的Request类
            req.Fields = "user_id,nick,created,buyer_credit,type,sex";
            req.Nick = "wuhuacong";
            UserGetResponse rsp = myclient.Execute(req);//执行API请求并将该类转换为response对象
            Console.WriteLine(rsp.Body);
            if (rsp.User != null)
            {
                //Console.WriteLine(rsp.User.Nick);
                //Console.WriteLine(ObjectToString(rsp.User));
                List<User> list = new List<User>();
                list.Add(rsp.User);
                this.winGridView1.DisplayColumns = req.Fields.Replace("_", "");//对应字段的属性没有“_”字符的
                this.winGridView1.DataSource = list;
            }
        }

        private void TestItemGet()
        {
            //单独商品的信息
            Console.WriteLine("单独商品的信息");
            ItemGetRequest req = new ItemGetRequest();
            req.Fields = "num_iid,title,nick,pic_path,cid,price,type,location.city,delist_time,post_fee";
            req.NumIid = 3838293428L;
            ItemGetResponse itemRsp = myclient.Execute(req);
            if (itemRsp != null && itemRsp.Item != null)
            {
                //Console.WriteLine(itemRsp.Item.Nick);
                //Console.WriteLine(ObjectToString(itemRsp.Item));
                List<Item> list = new List<Item>();
                list.Add(itemRsp.Item);
                this.winGridView1.DisplayColumns = req.Fields.Replace("_", "");//对应字段的属性没有“_”字符的
                this.winGridView1.DataSource = list;
            }
        }

        private void TestItemSearch()
        {
            //查询商品信息（不含类别）
            Console.WriteLine("查询商品信息（不含类别）");
            ItemsGetRequest req = new ItemsGetRequest();
            req.Fields = "num_iid,title,nick,pic_url,cid,price,type,delist_time,post_fee,score,volume";//,location.city,location.state";
            req.Q = "笔记本";
            //itemReq.Cid = "14";
            req.OrderBy = "volume:desc";
            req.PageNo = 1;
            req.PageSize = 40;

            //显示列表信息
            ItemsGetResponse itemRsp = myclient.Execute(req);
            if (itemRsp != null)
            {
                //Console.WriteLine(itemRsp.TotalResults);
                //foreach (Item item in itemRsp.Items)
                //{
                //    Console.WriteLine(ObjectToString(item));
                //}
                this.winGridView1.DisplayColumns = req.Fields.Replace("_", "");//对应字段的属性没有“_”字符的
                this.winGridView1.DataSource = itemRsp.Items;
            }

}

对于需要获取用户私密信息，如买入卖出等重要信息，还需要获取用户的SessionKey的，我们可以通过下面接口函数，弹出登录窗口，然后登录后，定位到对应的App应用页面，然后页面加载的时候，获取到对应的SessionKey、

  /// <summary>
        /// 判断是否顺利获取SessionKey
        /// </summary>
        /// <returns></returns>
        private string GetAuthorizeCode(string appKey)
        {
            string authorizeCode = "";
            FrmAuthorized dlg = new FrmAuthorized();
            dlg.AppKey = appkey;
            if (dlg.ShowDialog() == DialogResult.OK)
            {
                authorizeCode = dlg.AuthrizeCode;
            }
            if (string.IsNullOrEmpty(authorizeCode)) return null;

            string sessionKeyUrl = string.Format(TOP_AUTH_URL, authorizeCode);
            HttpHelper helper = new HttpHelper();
            string html = helper.GetHtml(sessionKeyUrl);
            //格式
            //top_appkey=1142&top_parameters=xxx&top_session=xxx&top_sign=xxx&encode=utf-8
            string reg = ".*?&top_session=(?<session>.*?)&top_sign";
            string sessionKey = CRegex.GetText(html, reg, 1);
            return sessionKey;

}

最后我们看看其中获取已买记录的接口实现如下所示。

  private void TestBuyInfo()
        {
            if (string.IsNullOrEmpty(sessionKey))
            {
                sessionKey = GetAuthorizeCode(this.appkey);
            }

            //买入交易
            Console.WriteLine("买入交易");
            TradesBoughtGetRequest req = new TradesBoughtGetRequest();
            //req.Fields = "tid,title,price,type,num_iid,seller_nick,buyer_nick,status";
            req.Fields = "tid,title,price,type,num_iid,seller_nick,buyer_nick,status,receiver_state,receiver_city,receiver_district,receiver_address";
            req.PageNo = 1L;
            req.PageSize = 40L;
            TradesBoughtGetResponse rsp = myclient.Execute(req, sessionKey);
            if (rsp != null)
            {
                //Console.WriteLine(rsp.Trades.Count);
                //if (rsp.Trades.Count > 0)
                //{
                //    foreach (Trade item in rsp.Trades)
                //    {
                //        Console.WriteLine(ObjectToString(item));
                //    }
                //}
                this.winGridView1.DisplayColumns = req.Fields.Replace("_", "");//对应字段的属性没有“_”字符的
                this.winGridView1.DataSource = rsp.Trades;
            }

}

以上利用了我的Winform分页控件进行数据展示，因此代码要简化一些，当然，也可以用DataGridView来进行数据显示，不过代码方面可能要多一些。

本文链接

20丰富多彩的网页设计的灵感

2012-02-09T23:35:00Z

我们将向您展示如何用颜色带给你一个很好的和个人的风格设计。由小细节和丰富多彩的排版完全丰富多彩的背景，有很多不同的颜色来启发你的灵感

The Neighbourhood

Shelton Fleming

Captain Dash

Dangers of Fracking

10 years in type

Brooks – Shoe Advisor

Shoppub

原文：http://webdesignledger.com/inspiration/20-inspiring-examples-of-colorful-web-designs

Life in my Shoes

espacio creativo

Macquarie University – Green Campus

La Maddalena

Kinetic

Pioneer Steez

small studio

Adrian Baxter

Gimme

Nike Vision

Formfett

Foundry Collective

Protest

作者：孟晨
出处：http://www.cnblogs.com/xiaoyao2011/
个人站: http://www.coderidea.com/
欢迎任何形式的转载，但请务必注明出处。

本文链接

SQLite学习手册(C/C++接口简介)

2012-02-09T23:23:00Z

一、概述：

   在SQLite提供的C/C++接口中，其中5个APIs属于核心接口。在这篇博客中我们将主要介绍它们的用法，以及它们所涉及到的核心SQLite对象，如database_connection和prepared_statement。相比于其它数据库引擎提供的APIs，如OCI、MySQL API等，SQLite提供的接口还是非常易于理解和掌握的。

二、核心对象和接口：

   1. 核心对象：
   在SQLite中最主要的两个对象是，database_connection和prepared_statement。database_connection对象是由sqlite3_open()接口函数创建并返回的，在应用程序使用任何其他SQLite接口函数之前，必须先调用该函数以便获得database_connnection对象，在随后的其他APIs调用中，都需要该对象作为输入参数以完成相应的工作。至于prepare_statement，我们可以简单的将它视为编译后的SQL语句，因此，所有和SQL语句执行相关的函数也都需要该对象作为输入参数以完成指定的SQL操作。

   2. 核心接口：
   1). sqlite3_open
   上面已经提到过这个函数了，它是操作SQLite数据库的入口函数。该函数返回的database_connection对象是很多其他SQLite APIs的句柄参数。注意，我们通过该函数既可以打开已经存在的数据库文件，也可以创建新的数据库文件。对于该函数返回的database_connection对象，我们可以在多个线程之间共享该对象的指针，以便完成和数据库相关的任意操作。然而在多线程情况下，我们更为推荐的使用方式是，为每个线程创建独立的database_connection对象。对于该函数还有一点也需要额外说明，我们没有必要为了访问多个数据库而创建多个数据库连接对象，因为通过SQLite自带的ATTACH命令可以在一个连接中方便的访问多个数据库。

   2). sqlite3_prepare
   该函数将SQL文本转换为prepared_statement对象，并在函数执行后返回该对象的指针。事实上，该函数并不会评估参数指定SQL语句，它仅仅是将SQL文本初始化为待执行的状态。最后需要指出的，对于新的应用程序我们可以使用sqlite3_prepare_v2接口函数来替代该函数以完成相同的工作。

   3). sqlite3_step
   该函数用于评估sqlite3_prepare函数返回的prepared_statement对象，在执行完该函数之后，prepared_statement对象的内部指针将指向其返回的结果集的第一行。如果打算进一步迭代其后的数据行，就需要不断的调用该函数，直到所有的数据行都遍历完毕。然而对于INSERT、UPDATE和DELETE等DML语句，该函数执行一次即可完成。

   4). sqlite3_column
   该函数用于获取当前行指定列的数据，然而严格意义上讲，此函数在SQLite的接口函数中并不存在，而是由一组相关的接口函数来完成该功能，其中每个函数都返回不同类型的数据，如：
   sqlite3_column_blob
    sqlite3_column_bytes
    sqlite3_column_bytes16
    sqlite3_column_double
    sqlite3_column_int
    sqlite3_column_int64
    sqlite3_column_text
    sqlite3_column_text16
    sqlite3_column_type
    sqlite3_column_value
    sqlite3_column_count
   其中sqlite3_column_count函数用于获取当前结果集中的字段数据。下面是使用sqlite3_step和sqlite3_column函数迭代结果集中每行数据的伪代码，注意这里作为示例代码简化了对字段类型的判断：

1     int fieldCount = sqlite3_column_count(...);
2     while (sqlite3_step(...) <> EOF) {
3         for (int i = 0; i < fieldCount; ++i) {
4             int v = sqlite3_column_int(...,i);
5         }
6     }

5). sqlite3_finalize
   该函数用于销毁prepared statement对象，否则将会造成内存泄露。

   6). sqlite3_close
   该函数用于关闭之前打开的database_connection对象，其中所有和该对象相关的prepared_statements对象都必须在此之前先被销毁。

三、参数绑定：

   和大多数关系型数据库一样，SQLite的SQL文本也支持变量绑定，以便减少SQL语句被动态解析的次数，从而提高数据查询和数据操作的效率。要完成该操作，我们需要使用SQLite提供的另外两个接口APIs，sqlite3_reset和sqlite3_bind。见如下示例：

 1     void test_parameter_binding() {
 2         //1. 不带参数绑定的情况下插入多条数据。
 3         char strSQL[128];
 4         for (int i = 0; i < MAX_ROWS; ++i) {
 5             sprintf(strSQL,"insert into testtable values(%d)",i);
 6             sqlite3_prepare_v2(..., strSQL);
 7             sqlite3_step(prepared_stmt);
 8             sqlite3_finalize(prepared_stmt);
 9         }
10         //2. 参数绑定的情况下插入多条数据。
11         string strSQLWithParameter = "insert into testtable values(?)";
12         sqlite3_prepare_v2(..., strSQL);
13         for (int i = 0; i < MAX_ROWS; ++i) {
14             sqlite3_bind(...,i);
15             sqlite3_step(prepared_stmt);
16             sqlite3_reset(prepared_stmt);
17         }
18         sqlite3_finalize(prepared_stmt);
19     }

这里首先需要说明的是，SQL语句"insert into testtable values(?)"中的问号(?)表示参数变量的占位符，该规则在很多关系型数据库中都是一致的，因此这对于数据库移植操作还是比较方便的。
   通过上面的示例代码可以显而易见的看出，参数绑定写法的执行效率要高于每次生成不同的SQL语句的写法，即2)在效率上要明显优于1)，下面是针对这两种写法的具体比较：
   1). 单单从程序表面来看，前者在for循环中执行了更多的任务，比如字符串的填充、SQL语句的prepare，以及prepared_statement对象的释放。
   2). 在SQLite的官方文档中明确的指出，sqlite3_prepare_v2的执行效率往往要低于sqlite3_step的效率。
   3). 当插入的数据量较大时，后者带来的效率提升还是相当可观的。

本文链接

Sharepoint学习笔记—Ribbon系列-- 2. 在Ribbon中添加新Tab

2012-02-09T21:31:00Z

有了上面的基础，我们来看看如何向Sharepoint网站的Ribbon中添加我们定义的Tab。

直接进入操作步骤

一、创建 SharePoint 项目

要添加新选项卡，应首先创建一个空白 SharePoint 项目。如下:

把此方案设置成Farm解决方案

然后在此项目中分别加入新的Feature与新的空白Element如下图

二、使用自定义操作中的功能区 XML 定义功能区自定义项

方法是打开 Elements.xml 文件,其内容如下:

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
    <CustomAction
      Id="MyCustomRibbonTab"
      Location="CommandUI.Ribbon.ListView"
      RegistrationId="101"
      RegistrationType="List">
        <CommandUIExtension>
            <CommandUIDefinitions>
                <CommandUIDefinition
                  Location="Ribbon.Tabs._children">
                    <Tab
                      Id="Ribbon.CustomTabExample"
                      Title="My Custom Tab"
                      Description="This holds my custom commands!"
                      Sequence="501">
                        <Scaling
                          Id="Ribbon.CustomTabExample.Scaling">
                            <MaxSize
                              Id="Ribbon.CustomTabExample.MaxSize"
                              GroupId="Ribbon.CustomTabExample.CustomGroupExample"
                              Size="OneLargeTwoMedium"/>
                            <Scale
                              Id="Ribbon.CustomTabExample.Scaling.CustomTabScaling"
                              GroupId="Ribbon.CustomTabExample.CustomGroupExample"
                              Size="OneLargeTwoMedium" />
                        </Scaling>
                        <Groups Id="Ribbon.CustomTabExample.Groups">
                            <Group
                              Id="Ribbon.CustomTabExample.CustomGroupExample"
                              Description="This is a custom group!"
                              Title="Custom Group"
                              Sequence="52"
                              Template="Ribbon.Templates.CustomTemplateExample">
                                <Controls Id="Ribbon.CustomTabExample.CustomGroupExample.Controls">
                                    <Button
                                      Id="Ribbon.CustomTabExample.CustomGroupExample.HelloWorld"
                                      Command="CustomTabExample.HelloWorldCommand"
                                      Sequence="15"
                                      Description="Says hello to the World!"
                                      LabelText="Hello, World!"
                                      TemplateAlias="cust1"/>
                                    <Button
                                      Id="Ribbon.CustomTabExample.CustomGroupExample.GoodbyeWorld"
                                      Command="CustomTabExample.GoodbyeWorldCommand"
                                      Sequence="17"
                                      Description="Says good-bye to the World!"
                                      LabelText="Good-bye, World!"
                                      TemplateAlias="cust2"/>
                                    <Button
                                      Id="Ribbon.CustomTabExample.CustomGroupExample.LoveWorld"
                                      Command="CustomTabExample.LoveWorldCommand"
                                      Sequence="19"
                                      Description="Says I love the World!"
                                      LabelText="I love you, World!"
                                      TemplateAlias="cust3"/>
                                </Controls>
                            </Group>
                        </Groups>
                    </Tab>
                </CommandUIDefinition>
                <CommandUIDefinition Location="Ribbon.Templates._children">
                    <GroupTemplate Id="Ribbon.Templates.CustomTemplateExample">
                        <Layout
                          Title="OneLargeTwoMedium"
                          LayoutTitle="OneLargeTwoMedium">
                            <Section Alignment="Top" Type="OneRow">
                                <Row>
                                    <ControlRef DisplayMode="Large" TemplateAlias="cust1" />
                                </Row>
                            </Section>
                            <Section Alignment="Top" Type="TwoRow">
                                <Row>
                                    <ControlRef DisplayMode="Medium" TemplateAlias="cust2" />
                                </Row>
                                <Row>
                                    <ControlRef DisplayMode="Medium" TemplateAlias="cust3" />
                                </Row>
                            </Section>
                        </Layout>
                    </GroupTemplate>
                </CommandUIDefinition>
            </CommandUIDefinitions>
            <CommandUIHandlers>
                <CommandUIHandler
                  Command="CustomTabExample.HelloWorldCommand"
                  CommandAction="javascript:alert('Hello, world!');" />
                <CommandUIHandler
                  Command="CustomTabExample.GoodbyeWorldCommand"
                  CommandAction="javascript:alert('Good-bye, world!');" />
                <CommandUIHandler
                  Command="CustomTabExample.LoveWorldCommand"
                  CommandAction="javascript:alert('I love you, world!');" />
            </CommandUIHandlers>
        </CommandUIExtension>
    </CustomAction>
</Elements>

下面对其内容作如下说明:

在对Ribbon进行自定义时，你需要把CustomAction 元素与Ribbon的XML 一起使用。CustomAction元素的Location 属性告知 CustomAction 在何处应用自定义项(即此元素内的所有自定义内容)。

下表对这些Location可能的值进行了说明。本例我们把Location值设置为CommandUI.Ribbon.ListView 也即我们此处定义的自定义项(Tab)将在我们显示列表视图的WebPart时出现在Ribbon区域，而基其它时候我们是看不见它的。

值	说明
CommandUI.Ribbon	对于指定的 RegistrationId，自定义项出现在任何地方。
CommandUI.Ribbon.ListView	当存在列表视图 Web 部件时出现自定义项。
CommandUI.Ribbon.EditForm	自定义项出现在编辑表单上。
CommandUI.Ribbon.NewForm	自定义项出现在新建表单上。
CommandUI.Ribbon.DisplayForm	自定义项出现在显示表单上。

关于RegistrationId属性：用于指定与此操作(CustomAction )关联的列表或项内容类型的标识符，或文件类型或编程标识符 (ProgID)。关于它们的含义请参见

Sharepoint学习笔记—Ribbon系列-- Reference :List definitions Type and BaseType ，此处我们设置为101也即我们自定义的CustomAction与

Document library //文档库进行关联。也就是说当我们选择Sharepoint网站的某个DocumentLibrary List时，就会出现我们自下定义的CustomAction选项卡(Tab),也就是说，

在CustomAction的相关属性设置中，我们解决了它显示的“时机”问题。

RegistrationType属性: 用于给每项操作指定注册附件。可能的值包括：ContentType,FileType,List,ProgId

CommandUIDefinition 元素上的 Location 定义其内部控件呈现的位置。在本示例中，您将引用服务器功能区(Ribbon)的 Tabs 集合(Ribbon.Tabs._childern)。_children 约定告知功能区将以下 XML 插入到输出中以便呈现功能区。在本例中，您将插入 Tab 元素 XML。

Tab元素中的Sequence 属性将定义Tab相对于其他Tabs所呈现的位置。Sharepoint系统默认的Tab使用 100 的整倍数作为它们的Sequence值，因此用户自定义的Tab的Sequence 属性不应是 100 的整倍数以防止与系统的默认Sequence值出现冲突。应避免冲突，以确保对功能区 XML 进行适当处理。

由此可见，CustomAction影响了显示的“时机”，此处CommandUIDefinition与Tab中的相关属性设置影响了显示的"位置"。

在创建自定义Tab时，您必须定义在添加控件时如何对Tab进行缩放。通过将 Scaling 元素与 GroupTemplate 一起使用可对此进行处理。

MaxSize 元素对组(Group)中控件的最大大小进行定义。而 Scale 元素定义组(Group)如何在不同的情况下进行缩放。

GroupId 属性将一个组与缩放大小相关联。

Size 属性由稍后在GroupTemplate 中定义的 Layout 元素定义。

Groups 元素对将在选项卡上出现的组进行定义。Group 元素自身具有与其他控件相似的属性以及一个 Template 属性。

Template 属性引用我们后面将要定义的 GroupTemplate，Sharepoin要求每一个Group都必须与某个特定的GroupTemplate项进行绑定，并推荐用户尽量使用用户自已定义的GroupTemplate.

Controls 元素包含将在组中出现的控件。组内部的控件必须定义 TemplateAlias 和 Command 属性。与Tab类似，每个控件具有一个 Sequence 属性，用于定义这些控件将在组中出现的位置。默认控件基于 10 的整倍数，所以任何自定义控件不应使用 10 的整倍数以避免发生冲突。Command 属性由 CommandUIHandler 元素使用，并且即使在未指定 CommandUIHandler 时也要求使用此属性。TemplateAlias 属性定义控件相对于 GroupTemplate 出现的位置。

定义组模板(GroupTemplate)时，您必须将其定义为另一个 CommandUIDefinition。CommandUIDefinition 具有 Ribbon.Templates._children 位置。这与用于组和选项卡的模式相同。

GroupTemplate 元素包含一个 Layout 元素，后者又包含 Section 或 OverflowSection 元素。Layout 元素具有一个 Title 属性，可用于 MaxSize 和 Scale 元素上的 Size 属性。

Section 元素具有两个属性。Alignment 属性对以下 Row 元素中的控件所处的位置进行定义。Type 属性定义将在对应的部分显示的行数。一个 Section 最多具有三个 Row 元素。

Row 元素包含一个或多个 ControlRef 元素。每个 ControlRef 元素定义一个控件在功能区的显示方式。DisplayMode 属性包含以下值(注:并非所有的控件都提供所有的 DisplayMode 值)。

值	说明
Small	显示为无标签文本的小图标。
Medium	显示为带有标签文本的 16 x 16 的图标。
Large	显示为带有标签文本的 32 x 32 的图标。
Text	仅显示为文本。

还可以有一个 OverflowSection 元素而不是 Section 元素。此元素定义一个区域，在此区域中，不必使用 Row 元素即可显示多个控件。所有的控件都将显示为由 DisplayMode 属性定义的相同大小。DividerAfter 和 DividerBefore 属性定义在显示溢出部分时分隔线将出现的位置。

向默认功能区位置添加控件时，您应该考虑组模板和缩放。向默认位置添加控件可改变组的显示。大多数默认组模板包含将随自定义控件一起增长的溢出部分。在更高级的方案中，您可以重写缩放来根据设计需要显示控件。

CommandUIHandlers 元素包含所有 CommandUIHandler 元素。CommandUIHandler 元素定义功能区上的控件如何响应某个操作。Command 属性是与随控件定义的 Command 属性一起使用的命令的唯一名称。CommandAction 属性包含可对控件执行的操作。此操作可以是 ECMAScript（JavaScript、JScript）、URL 或 UrlAction 元素中以前包含的任意内容。

三、部署自定义项
    按 F5。Visual Studio 2010 中的 SharePoint 开发工具将自动构建和部署功能。
    转到网站或子网站中的文档库。
   单击“My Custom Tab”选项卡，查看“自定义组”，然后单击“Hello, World”、“Good-bye, World”或“I Love You, World”按钮。

本文链接

【jquery版.net控件—dropdownlist】附源码，欢迎大家指点、指正、拍砖！！！

2012-02-09T17:04:00Z

前言

为了2012第一个春天，为了我那卑微的工资，为了我那伟大的爱情............................

其实是为了自我能力的提升罢了，呵呵！！！（也是为了涨工资吧...）

小弟准备向web前段开炮，而对js与jq都是初学，现在借博客园这块宝地来督促自己，借博客园的高手来提点自己。

小弟准备陆陆续续用jquery模仿一点.net的控件以提高自己，顺便看看能不能弄一点可用插件出来，各位大哥看到了多多指点哦。

控件简单应用

效果图

1 初始化效果

生成的html代码

2 控件选项改变事件以及列表项点击事件（最后三项后期加入未作事件绑定）

3 前台调用代码

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title></title>
    <script src="scripts/jquery-1.4.1.js" type="text/javascript"></script>
    <script src="js/dropDownList.js" type="text/javascript"></script>
    <script type="text/javascript">
        $(document).ready(function () {
            var data = [];
            for (var i = 0; i < 3; i++) {
                data[i] = {};
                data[i]["v"] = "value_" + i.toString();
                data[i]["t"] = "text_" + i.toString();
            }

            var $div = $("#divwl");
            var drop1 = new dropDownList("drop1");

            drop1.event.onChange = onSelectChanged;
            drop1.itemEvent.onClick = onItemClick;
            drop1.dataSource = data;
            drop1.dataValueField = "v";
            drop1.dataTextField = "t";
            drop1.dataTitleField = "v";
            drop1.dataBind($div);

            drop1.setSelectedText("text_2");

            //动态添加选择项，此处选择项没有事件
            for (var i = 0; i < 3; i++) {
                var v = "inertValue_" + i;
                var t = "insertText_" + i;
                var _item = new item(v, t);
                _item.load();
                drop1.insertItem(_item);
            }
            drop1.style.width = '300px';
            drop1.style.height = '25px';
            drop1.style.background = 'Gray';
            drop1.styleLoad();

            //事件处理函数
            function onItemClick() {
                var sender = this;
                var optionSender = sender.htmlElement;
                var selectedValue = optionSender.val();
                var item = sender;
                var $div = $("#itemText");
                $div.html("单项点击事件<hr/>" + "当前项：" + item.attribute.text + "<br/>当前值：" + selectedValue);
                $div.fadeIn(500);
                $div.fadeOut(5000);
            }
            function onSelectChanged() {
                var sender = this;
                var dropSender = sender.htmlElement;
                var selectedValue = dropSender.val()
                var item = sender.getSelectedItem();
                var $div = $("#text");
                $div.html("dropdownlist的改变事件<hr/>" + "当前项：" + item.attribute.text + "<br/>当前值：" + selectedValue);
                $div.fadeIn(500);
                $div.fadeOut(5000);
            }
            function onSelectClick() {
                var sender = this;
                var dropSender = sender.htmlElement;
                var selectedValue = dropSender.val()
                var $div = $("#text");
                $div.html("dropdownlist的点击事件，当前值：" + selectedValue);
                $div.fadeIn(500);
                $div.fadeOut(5000);
            }

        });
      
    </script>
</head>
<body>
    <div id="divwl">
    </div>
    <div id="text">
    </div>
    <div id="itemText">
    </div>
</body>
</html>

1 数据源

数据源为我们动态写入的数组。

var data = [];
            for (var i = 0; i < 3; i++) {
                data[i] = {};
                data[i]["v"] = "value_" + i.toString();
                data[i]["t"] = "text_" + i.toString();
            }

            var $div = $("#divwl");
            var drop1 = new dropDownList("drop1");

2 基本调用说明

1  drop1.event.onChange = onSelectChanged;
2             drop1.itemEvent.onClick = onItemClick;
3             drop1.dataSource = data;
4             drop1.dataValueField = "v";
5             drop1.dataTextField = "t";
6             drop1.dataTitleField = "v";
7             drop1.dataBind($div);
8 
9             drop1.setSelectedText("text_2");

与.net控件基本一致，给定数据源，但是我这里多出了一个dataTitleField用以显示提示框。

其中，drop1.event.onChange = onSelectChanged;为select 的事件

drop1.itemEvent.onClick = onItemClick; 为option的事件绑定

注意，此处事件绑定采用的是call的用法，所以下方函数：中的this作用域环境要注意。

3 动态添加列表项

1  //动态添加选择项，此处选择项没有事件
2             for (var i = 0; i < 3; i++) {
3                 var v = "inertValue_" + i;
4                 var t = "insertText_" + i;
5                 var _item = new item(v, t);
6                 _item.load();
7                 drop1.insertItem(_item);
8             }

此处添加的项，便没有做事件绑定了。

再下面的代码便是对应函数便不多说了。

控件数据源Ajax获取应用

1 效果图

基本界面

Ajax获得json数据源：

[{"id":1,"name":"河北"},{"id":2,"name":"江苏"},{"id":3,"name":"四川"},{"id":4,"name":"贵州"}]

对应数据库数据：

点击对应省份引发改变事件

获取数据源：

[{"id":8,"provinceId":3,"name":"成都"},{"id":9,"provinceId":3,"name":"绵阳"},{"id":10,"provinceId":3,"name":"遂宁"},{"id":11,"provinceId":3,"name":"南充"}]

前台调用代码：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title></title>
    <script src="scripts/jquery-1.4.1.js" type="text/javascript"></script>
    <script src="js/dropDownList.js" type="text/javascript"></script>
    <script type="text/javascript">
        $(document).ready(function () {
            var dataProvince = null;
            $.ajax({
                type: "post",
                url: "Ajax.aspx?sql=select  * from province   ",
                type: "json",
                async: false,
                success: function (data) {
                    dataProvince = data;
                }
            });

            var $div = $("#province");
            var drop1 = new dropDownList("dropProvince");
            drop1.event.onChange = onSelectChanged;
            drop1.dataSource = dataProvince;
            drop1.dataValueField = "id";
            drop1.dataTextField = "name";
            drop1.dataTitleField = "name";
            drop1.dataBind($div);
            var _item = new item("-1", "==请选择省份==");
            drop1.insertItem(_item);
            drop1.setSelectedText("==请选择省份==");

            function onSelectChanged() {
                var sender = this;
                //                var provinceId = sender.getSelectedValue();//也可以
                var provinceId = drop1.getSelectedValue();

                var dataProvince = null;
                $.ajax({
                    type: "post",
                    url: "Ajax.aspx?sql=select  * from city where provinceId=" + provinceId + "   ",
                    type: "json",
                    async: false,
                    success: function (data) {
                        dataProvince = data;
                    }
                });
                var $div1 = $("#city");
                var dropCity = new dropDownList("dropCity");

                $div1.html("市：");
                dropCity.dataSource = dataProvince;
                dropCity.dataValueField = "id";
                dropCity.dataTextField = "name";
                dropCity.dataTitleField = "name";
                dropCity.dataBind($div1);

            }

        });
      
    </script>
</head>
<body>
    <div id="province">
        省：
    </div>
    <hr />
    <div id="city">
        市：
    </div>
</body>
</html>

这个我便暂时不说明了吧，很晚了，明天还要上班呢......

因为不知道看的人多不多，也不知道大家有没有问他，若是有问题我再解答吧，具体请大家自己去运行吧。

dropdownlist源代码

本文链接

基于ArcGIS10.0和Oracle10g的空间数据管理平台十五（C#开发）-空间数据导出

2012-02-09T16:58:00Z

我的新浪微博：http://weibo.com/freshairbrucewoo。

欢迎大家相互交流，共同提高技术。

又是晚上12点以后了，今晚等待人民网的最新新闻也是没有结果，还是称这个时间写一篇博客吧！我是程序员但是也关心国家大事，自己没有太大的要求，就喜欢有一个稳定和安心的生活和工作环境，仅此而已！

今天这篇博客还是基于ArcGIS10.0和Oracle10g的空间数据管理平台的设计与实现的继续，前面有一篇博客（十三）介绍空间数据导入的，今天介绍一篇空间数据导出。空间数据导出的作用主要是以另一种形式保存，方便部分数据的转移。下面开始介绍具体实现过程。

1.定义个SDE的工作空间并且在构造函数中初始化

 1        private IFeatureWorkspace pWorkspaceSDE;//定义SDE工作空间
 2         public FrmDataExport()
 3         {
 4             InitializeComponent();
 5             if (pWorkspaceSDE == null)
 6             {
 7                 //获取工作空间的一个实例
 8                 pWorkspaceSDE = MapOperation.GetFeatrueWorkspace();
 9             }
10         }

2.在form的load函数中初始化表信息，这些表就是可以被导出空间数据表。

 1         /// <summary>
 2         /// 列出所有的表信息
 3         /// </summary>
 4         /// <param name="sender"></param>
 5         /// <param name="e"></param>
 6         private void FrmDataExport_Load(object sender, EventArgs e)
 7         {
 8             SqlHelper sh = new SqlHelper();
 9             string sql = string.Empty;
10             sql = "select table_name,table_mapname,type from jcsjk_layer l,jcsjk_element e where "
11                 + "e.id=l.pid and e.category='地震矢量数据'";
12             OracleDataReader odr = sh.ReturnDataReader(sql);
13             object[] obj = new object[4];
14             while (odr.Read())
15             {
16                 obj[0] = false;
17                 obj[1] = odr[0].ToString();
18                 obj[2] = odr[2].ToString();
19                 obj[3] = odr[1].ToString();
20                 dataGridViewX1.Rows.Add(obj);
21             }
22             comboBoxEx1.SelectedIndex = 0;
23         }

3.选择多处数据的格式并做相应的准备工作

 1         /// <summary>
 2 /// 根据选择的导出数据格式打开相应的文件
 3 /// </summary>
 4 /// <param name="sender"></param>
 5 /// <param name="e"></param>
 6         private void selectPathBtn_Click(object sender, EventArgs e)
 7         {
 8             //根据导出数据格式打开相应的文件
 9             switch (comboBoxEx1.SelectedIndex)
10             {
11                 case 0:
12                     {
13                         FolderBrowserDialog folder = new FolderBrowserDialog();
14                         if (folder.ShowDialog() == DialogResult.OK)
15                         {
16                             if (folder.SelectedPath != "")
17                             {
18                                 selectPathTxt.Text = folder.SelectedPath;
19                             }
20                         }
21                     }
22                     break;
23                 case 1:
24                     { 
25                         OpenFileDialog ofd = new OpenFileDialog();
26                         ofd.Filter = "MDB文件(.mdb) | *.mdb";
27                         ofd.CheckFileExists = false;
28 
29                         if (ofd.ShowDialog() == DialogResult.OK)
30                         {
31                             
32                             if (ofd.FileName != "")
33                             {
34                                 selectPathTxt.Text = ofd.FileName;
35                             }
36                         }
37                     }
38                     break;
39                 default:
40                     break;
41             }
42         }

4.执行具体的导出功能

 1         /// <summary>
 2 /// 执行具体的导出功能
 3 /// </summary>
 4 /// <param name="sender"></param>
 5 /// <param name="e"></param>
 6         private void exportBtn_Click(object sender, EventArgs e)
 7         {
 8             if (selectPathTxt.Text == "")
 9             {
10                 MessageBox.Show("请选择导出路劲");
11                 return;
12             }
13             IWorkspaceFactory pWF = null;
14             switch (comboBoxEx1.SelectedIndex)
15             {
16                 case 0:
17                     {
18                         if (!File.Exists(selectPathTxt.Text))
19                         {
20                             
21                         }
22                         //创建一个输出shp文件的工作空间
23                         pWF = new ShapefileWorkspaceFactoryClass();
24                         IFeatureWorkspace pFW = pWF.OpenFromFile(selectPathTxt.Text, 0) as IFeatureWorkspace;
25                         IWorkspace pW = pFW as IWorkspace;
26 
27                         for (int i = 0; i < dataGridViewX1.Rows.Count; ++i)
28                         {
29                             if (bool.Parse(dataGridViewX1.Rows[i].Cells[0].Value.ToString()))
30                             {
31                                 if (dataGridViewX1.Rows[i].Cells[2].Value.ToString() != "PA")
32                                 {
33                                     string str = dataGridViewX1.Rows[i].Cells[1].Value.ToString();
34                                     MapOperation.ConvertFeatureClass(pWorkspaceSDE as IWorkspace,
35                                         pW, str, str, 4326);
36                                 } 
37                                 else
38                                 {
39                                     MessageBox.Show("属性表不能够导出为Shape文件");
40                                 }
41                             }
42                         }
43                         MessageBox.Show("导出数据完成!");
44                     }
45                     break;
46                 case 1:
47                     {
48                         // Instantiate an Access workspace factory and create a new personal geodatabase.
49                         pWF = new AccessWorkspaceFactoryClass();
50                         IWorkspaceName pWN = pWF.Create(Path.GetDirectoryName(selectPathTxt.Text),
51                              Path.GetFileName(selectPathTxt.Text),null, 0);
52 
53                         // Cast the workspace name object to the IName interface and open the workspace.
54                         IName pN = (IName)pWN;
55                         IWorkspace pW = (IWorkspace)pN.Open();
56 
57                         for (int i = 0; i < dataGridViewX1.Rows.Count; ++i)
58                         {
59                             if (bool.Parse(dataGridViewX1.Rows[i].Cells[0].Value.ToString()))
60                             {
61                                 string str = dataGridViewX1.Rows[i].Cells[1].Value.ToString();
62                                 if (dataGridViewX1.Rows[i].Cells[2].Value.ToString() != "PA")
63                                 {
64                                     MapOperation.ConvertFeatureClass(pWorkspaceSDE as IWorkspace,
65                                        pW, str, str, 4326);
66                                 } 
67                                 else
68                                 {
69                                     ITable pSourceT = pWorkspaceSDE.OpenTable(str);
70                                     IFeatureWorkspace pFW = pW as IFeatureWorkspace;
71                                     ITable pTargetT = pFW.CreateTable(str, pSourceT.Fields, null, null, "");
72                                     FusedIndexTable(ref pSourceT, ref pTargetT);
73                                 }
74                             }
75                         }
76                         MessageBox.Show("导出数据完成!");
77                     }
78                     break;
79                 default:
80                     break;
81             }
82         }

5.如果导出的是mdb的格式，而且是以追加的方式，那么下面的函数将实现这个功能。

 1         /// <summary>
 2 /// 如果目的数据库中已经有表，则将新的记录追加进去 
 3 /// </summary>
 4 /// <param name="FromTable">导出表</param>
 5 /// <param name="ToTable">导入表</param>
 6         private void FusedIndexTable(ref ITable FromTable, ref ITable ToTable)
 7         {
 8             if (FromTable == null || ToTable == null)
 9             {
10                 return;
11             }
12             IRow pFromRow;
13             ICursor pToCursor, pFromCursor;
14             IRowBuffer pToRowBuffer;
15             int pIndex;
16 
17             pToRowBuffer = ToTable.CreateRowBuffer();
18             pToCursor = ToTable.Insert(true);
19             pFromCursor = FromTable.Search(null, false);
20             pFromRow = pFromCursor.NextRow();
21             while (pFromRow != null)
22             {
23                 for (int i = 0; i < pFromRow.Fields.FieldCount; i++)
24                 {
25                     pIndex = pToRowBuffer.Fields.FindField(pFromRow.Fields.get_Field(i).Name.Trim());
26                     if (pFromRow.Fields.get_Field(i).Editable && pIndex > -1)
27                     {
28                         pToRowBuffer.set_Value(pIndex, pFromRow.get_Value(i));
29                     }
30                 }
31 
32                 pToCursor.InsertRow(pToRowBuffer);
33                 pFromRow = pFromCursor.NextRow();
34             }
35             System.Runtime.InteropServices.Marshal.ReleaseComObject(pToCursor);
36             pFromRow = null;
37             pFromCursor = null;
38             pToRowBuffer = null;
39         }

6.其他功能：主要就是一些小功能，例如界面的布局设计，选择导出的文件名，导出以后即使清空文件名等。

总结：其实空间数据导出功能也是主要用到一个技术：就是空间数据格式的相互转换。这个技术也是空间数据导入使用的主要功能或技术。还有一点值得提的是：把所有的表以及表的一些描述信息以列表的形式展现出来方便用户选择，选择的策略是任意多个需要导出的表，但是同时只能选择一种格式。如果需要导出多种格式，就需要多执行几次导出功能，这点是可以改进的地方，也可以用多选项给出，然后根据用户选择一次性导出多种格式，这样也简单的提升了用户使用的效率。呵呵，优化无处不在。

本文链接

深入浅出三层架构

2012-02-09T16:35:00Z

这几天看了不少三层架构的资料，整理整理

——故写篇博文谈谈自己的看法。

三层架构概念：

三层架构(3-tier application) 通常意义上的三层架构就是将整个业务应用划分为：表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）。区分层次的目的即为了“高内聚，低耦合”的思想，复杂项目不能把SQL语句直接写到程序里，不模块话，难以维护。应该采取三层架构。

1、表现层（UI）：通俗讲就是展现给用户的界面，即用户在使用一个系统的时候他的所见所得。

2、业务逻辑层（BLL）：针对具体问题的操作，也可以说是对数据层的操作，对数据业务逻辑处理。

3、数据访问层（DAL）：该层所做事务直接操作数据库，针对数据的增添、删除、修改、查找等。

简单的说，UI层调用BLL，BLL调用DAL，数据用Model进行传递，Model为各层之间架起了数据传输的桥梁。

参考模型：UI<-->Model<-->BLL<-->Model<-->DAL

下面我以一个简单的例子来细数三层架构：

代码剖析：

新建一个项目（Windows 窗体应用程序），再在根目录下新建3个文件夹，分别是Model,DAL,BLL。

在Model下添加一个Person类

在DAL下添加一个SQLHelper类和一个PersonDAL类。

在BLL下添加PersonBLL类

Person.cs代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 三层架构Demo.Model
{
    class Person
    {
        public int Id { get;set;}
        public int Age { get; set; }
        public string Name { get; set; }

    }
}

SQLHelper类，封装了数据库操作的方法：

SQLHelper.cs代码入下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Configuration;
using System.Data;

namespace 三层架构Demo.DAL
{
    class SQLHelper
    {
        //public static readonly string connStr = System.Configuration.ConfigurationSettings.AppSettings["dbconnstr"];
        //获得连接字符串
        public static readonly string connStr =
            ConfigurationManager.ConnectionStrings["dbconnstr"].ConnectionString;

        /// <summary>
        /// 执行方法ExecuteNonQuery
        /// </summary>
        /// <param name="cmdText">要执行的sql语句</param>
        /// <param name="parameters">参数数组</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(string cmdText,
            params SqlParameter[] parameters)
        {
            using (SqlConnection conn=new SqlConnection (connStr))
            {
                conn.Open();
                using (SqlCommand cmd= conn.CreateCommand())
                {
                    cmd.CommandText = cmdText;
                    cmd.Parameters.AddRange(parameters);
                    int i=cmd.ExecuteNonQuery();
                    return i;
                }
            }
        }

        /// <summary>
        /// 执行ExecuteScalar() 返回第一行第一列数据
        /// </summary>
        /// <param name="cmdText">要执行的sql语句</param>
        /// <param name="parameters">参数数组</param>
        /// <returns>返回第一行第一列数据</returns>
        public static  object ExecuteScalar(string cmdText,
            params SqlParameter[] parameters)
        {
            using (SqlConnection conn=new SqlConnection(connStr))
            {
                conn.Open();
                using (SqlCommand cmd=conn.CreateCommand())
                {
                    cmd.CommandText = cmdText;
                    cmd.Parameters.AddRange(parameters);
                    return cmd.ExecuteScalar();
                }
            }
        }

        /// <summary>
        /// 执行ExecuteDataTable（）方法
        /// </summary>
        /// <param name="cmdText">要执行的Sql语句</param>
        /// <param name="parameters">参数数组</param>
        /// <returns>返回一个DataTable</returns>
        public static  DataTable ExecuteDataTable(string cmdText,
            params SqlParameter[] parameters)
        {
            using (SqlConnection conn=new SqlConnection (connStr))
            {
                conn.Open();
                using (SqlCommand cmd=conn.CreateCommand())
                {
                    cmd.CommandText = cmdText;
                    cmd.Parameters.AddRange(parameters);
                    using ( SqlDataAdapter adapter=new SqlDataAdapter (cmd))
                    {
                        DataTable dt = new DataTable();
                        adapter.Fill(dt);
                        return dt;
                    }
                }
            }
        }

       /// <summary>
        /// 执行ExecuteSqlDataReader()方法
       /// </summary>
       /// <param name="cmdText">要执行的Sql语句</param>
       /// <param name="parameters">参数数组</param>
        /// <returns>返回一个SqlDataReader</returns>

        public static SqlDataReader ExecuteSqlDataReader(string cmdText,
            params SqlParameter[] parameters)
        {
            using (SqlConnection conn=new SqlConnection (connStr))
            {
                conn.Open();
                using (SqlCommand cmd=conn.CreateCommand())
                {
                    cmd.CommandText = cmdText;
                    cmd.Parameters.AddRange(parameters);
                    return cmd.ExecuteReader();
                }
            }
        }                                                 
    }
}

PersonDAL.cs代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using 三层架构Demo.Model;
using System.Data.SqlClient;
using System.Data;

namespace 三层架构Demo.DAL
{
    class PersonDAL
    {
        /// <summary>
        /// 返回一个新增对象的主键，设为自动增长
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Addnew(Person model)
        {
            string sql = "insert into T_person(Age,Name) output inserted.id values(@Age,@Name)";
         
            object obj=
                SQLHelper.ExecuteScalar(sql,new SqlParameter("Age",model.Age),new SqlParameter("Name",model.Name));
            //Convert ： 与 value 等效的 32 位有符号整数，如果 value 为 null，则为零。
            return Convert.ToInt32(obj);
        }
        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int Delete(int id)
        {
            string sql = "delete form T_Person where Id=@Id";
            return SQLHelper.ExecuteNonQuery(sql,new SqlParameter("Id",id));
        }
        /// <summary>
        /// 修改数据
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Update(Person model)
        {
            string sql = "update T_Person set Age=@Age,Name=@Name where Id=@Id";
            return SQLHelper.ExecuteNonQuery(sql,new SqlParameter("Age",model.Age),new SqlParameter("Name",model.Name),
                new SqlParameter("Id",model.Id));
        }

        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public Person Get(int id)
        {
            string sql="select * from T_Person where Id=@Id";
            DataTable dt=SQLHelper.ExecuteDataTable(sql,new SqlParameter("Id",id));
            if (dt.Rows.Count<=0)
            {
                return null;
            }
            else if (dt.Rows.Count==1)
            {
                Person model1 = new Person();
                model1.Id = Convert.ToInt32(dt.Rows[0]["Id"]);
                model1.Name = Convert.ToString(dt.Rows[0]["Name"]);
                model1.Age = Convert.ToInt32(dt.Rows[0]["Age"]);
                return model1;
            }
            else//以防意外情况
            {
                throw new Exception("数据库中有两条及以上重复数据");
            }
        }
        /// <summary>
        /// 获取全部数据
        /// </summary>
        /// <returns></returns>
        public IEnumerable<Person> GetAll()
        {
            string sql = "select * from T_Person";
            DataTable dt = SQLHelper.ExecuteDataTable(sql);
            List<Person> list = new List<Person>();
            foreach (DataRow row in dt.Rows)
            {
                Person model = new Person();
                model.Id = Convert.ToInt32(row["Id"]);
                model.Name =Convert.ToString(row["Name"]);
                model.Age = Convert.ToInt32(row["Age"]);
                list.Add(model);
            }
            return list;
        }
    }
}

进行逻辑判断的BLL层代码看似是这样的：

PersonBLL.cs代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using 三层架构Demo.Model;
using 三层架构Demo.DAL;
using System.Data.SqlClient;
using System.Data;

namespace 三层架构Demo.BLL
{
    class PersonBLL
    {
        public int Addnew(Person model)
        {
            return new PersonDAL().Addnew(model);
        }

        public int Delete(int id)
        {
            return new PersonDAL().Delete(id);
        }

        public int Update(Person model)
        {
            return new PersonDAL().Update(model);
        }

        public Person Get(int id)
        {
            return new PersonDAL().Get(id);
        }

        public IEnumerable<Person> GetAll()
        {
            return new PersonDAL().GetAll();
        }


    }
}

UI层进行测试：

Form1.cs代码如下：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using 三层架构Demo.Model;
using 三层架构Demo.DAL;
using 三层架构Demo.BLL;

namespace 三层架构Demo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //Person p1 = new Person();
            //p1.Age = 22;
            //p1.Name = "Eyes";
            //int id=new PersonDAL().Addnew(p1);
            //MessageBox.Show(id.ToString());

            //PersonDAL p = new PersonDAL();
            //Person a = p.Get(1);
            //a.Name = "jack";
            //MessageBox.Show(a.Name + "," + a.Age);
            //p.Update(a);


            //PersonBLL bll = new PersonBLL();
            //Person p = bll.Get(1);
            //p.Name = "Admin";
            //MessageBox.Show(p.Name + "," + p.Age);
            //bll.Update(p);

            PersonBLL b = new PersonBLL();
            List<Person> list = (List<Person>)b.GetAll();
            foreach (Person item in list)
            {
                MessageBox.Show(item.Id+","+item.Name+","+item.Age);
            }
            
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            dataGridView1.DataSource = new PersonBLL().GetAll();
        }
    }
}

总结：

优点

1、开发人员可以只关注整个结构中的其中某一层；

2、可以很容易的用新的实现来替换原有层次的实现；

3、可以降低层与层之间的依赖；

4、有利于标准化；

5、利于各层逻辑的复用。

缺点

1、降低了系统的性能。这是不言而喻的。如果不采用分层式结构，很多业务可以直接造访数据库，以此获取相应的数据，如今却必须通过中间层来完成。

2、有时会导致级联的修改。这种修改尤其体现在自上而下的方向。如果在表示层中需要增加一个功能，为保证其设计符合分层式结构，可能需要在相应的业务逻辑层和数据访问层中都增加相应的代码。

3、增加了开发成本。

本文链接

NUnit之Attribue详解

2012-02-09T16:01:00Z

在上一篇文章“NUnit之Assertion详解”中，给大家介绍了NUnit的断言，现在接着给大家介绍Attribute在NUnit中的具体作用。

Attribute是C#一个重要的语言特征，园子里应该有不少这方面的文章，如果对Attribute不太了解，建议先去稍稍了解一下，亲手做个小程序感受一下Attribute的作用。

我们在使用NUnit编写测试用例时，离不开两个最基本的Attribute，例如，我们要测试一个类的Add方法，使用的代码如下：

[TestFixture]
public class MyTest
{
    [Test]
    public void TestAdd()
    {
        int a = 99;
        int b = 1;
        int value = MyMath.Add(a,b);
        Assert.AreEqual(value, 100);
    }

    Public void TestDel()
    {
       int value = MyMath.del(99,1);
       Assert.AreEqual(value, 98);
    }
}

上面的代码中，已经使用了两个Attribute，即[TestFixture]和[Test]，其中[TestFixture]的作用是声明MyTest类是一个含有测试方法的类，而[Test]则说明TestAdd是一个测试方法，而TestDel由于没有用[Test]声明，所以它不是测试方法，虽然它以Test开头。

对于编译后的Assembly文件，NUnit就是通过查找[TestFixture]和[Test]这类它支持的与测试相关的Attribute来确定哪些类包含了测试方法，以及这些类中的哪些方法是测试方法。

对于上面的例子，如果用NUnit的图形化界面打开其编译后的Assembly，应该看到如下的界面，TedtAdd方法以及它所属的命名空间按照树的形式展开，而TestDel方法由于没有[Test]的声明，所以它只是一个普通的方法，也就没有在树中展现：

点击Run按钮后，NUnit会运行所有的测试方法，运行后的界面如下

通过上面的小例子，我们知道了[TestFixture]和[Test]这两个Attribute的作用，对它支持的Attribute有了初步了解。

如果查看NUnit的源代码(大家可以去官网注册然后下载)，可以知道，在NUnit.Framework这个命名空间中，有TestFixtureAttribute和TestAttribute两个类，它们负责解析带有[TestFixture]和[Test]声明的类和方法（在C#语法规范中，要实现一个名称为[ABC]的Attribute，必须建立名称为ABCAttribute的类，并继承于Attribute这个基类）。

NUnit支持的Attribute远不止上面两个，我大致把它们分为四大类，分别是控制类、数值类、平台类和其它类，下面逐一介绍

一：控制类

这些Attribute控制测试类或者测试方法，而且成对出现，功能基本相比，了解一个就自然了解另外一个。

[TestFixture]/[Explicit]：声明一个类是测试类/声明一个类只有在UI界面被选中时才执行

[TestFixtureSetup]/[TestFixtureTearDown]：在测试开始前/结束后要执行的操作，一个TestFixture只能有一个TestFixtureSetup或TestFixtureTearDown。

[Test]/[Ignore]：是测试方法/忽略掉，测试时不执行

[Setup]/[TearDown]：每个测试方法在执行前/结束后要执行的操作

二：数值类

数值类Attribue是NUnit的一大亮点，善于使用这些Attribue，将使测试方法变得清晰、简洁、可读性强、可扩展性强，有利于进行数据驱动下的测试。

为了说明下面的例子，使用下面的方法，也就是打印输出输入值及其数据类型，这样便于把执行的结果通过打印的方式在NUnit中输出

Console.WriteLine(t + ", its type:" + typeof(T));

[Values]：以参数的形式传入一组值，NUnit会把这组值分解成相应数量的子测试。

例如下面的代码，分别在[Values]中传入三组共8个值，在执行时便一共会分解成8个子测试方法，例如

TestPrintInt([Values(1, 2, 3)] int x)会被分解为
TestPrintInt(1)
TestPrintInt(2)
TestPrintInt(3)三组

如下图，当选中ValueDemo这个节点，然后点击Run按钮后，会看到一共测试了8个测试用例。

当了解了这个Attribue的设计思路后，以后的其它Attribute也就很容易理解了，往往通过它们的命名就可以猜出一二。

[ValueSource]：以数据源（Object类型）作为参数，如下图，左边是源程序，右边是编译后生成的子测试

[Combinatorial]：两组测试数据进行组合，下面的代码会生成12个子测试，如图

[Sequential]：和上面[Combinatorial]的类似，不同之处见下图

下面其它的Attribue也都大同小异，不愿意看文字说明的话，大家用NUnit运行一下示例程序，再对比一下源程序就知道了

[Range]：生成某个数据范围内的子测试，如

TestPrintColsole([Range(0.2, 0.6, 0.2)] double d)：生成0.2,0.4,0.6三个子测试用例

TestPrintColsole([Values(1, 2, 3, 4, 5, 6)] int x, [Range(0.2, 0.6, 0.2)] double d)：两个Attribuee结合，共生成18个子测试用例

[Random]：在某个范围内随机生成测试用例，

TestPrintColsole([Random(-1.0, 1.0, 5)] double d)：-1到1之间生成5个测试用例

TestPrintColsole([Values(1, 2, 3, 4, 5, 6)] int x, [Random(-1.0, 1.0, 5)] double d) ：共生成30个子测试用例

三：平台类

[Culture]：当Culture满足某条件下，才执行测试，如：

[Culture("fr-FR")]：仅当在法文Culture时，执行测试

[Culture(Exclude = "en,de")]：非英文和德文Culture时，才执行测试

[Platform]：当Platform满足某条件下，才执行测试，如：

[Platform("NET-4.0")]：仅当framework版本是4.0时，才执行测试

下面是NUnit官网声称的，其支持的平台类型:

Win	Win32	Win32S	Windows	Win32NT
WinCE	Win95	Win98	WinMe	NT3
NT4	NT5	NT6	Win2K	WinXP
Win2003Server	Vista	Win2008Server	Win2008ServerR2	Windows7
Unix	Linux	Net	Net-1.0	Net-1.1
Net-2.0	Net-3.0	Net-3.5	Net-4.0	NetCF
SSCLI	Rotor	Mono	Mono-1.0	Mono-2.0
Mono-3.0	Mono-3.5

四：其它类

[Category]：将测试方法分组，NUnit会取出所有的组名，列在Categories中，点击它可以看到。这提供了另外一种测试用例的运行方法，用户可以在些选择某一类的用例进行测试，而不是只能以点击分单位

[ExpectedException]：运行时抛出的异常才能预期的行为。

如果没有这个Attribute，要测试某些异常时，只能使用Try Catch的方式，而下面的代码则更为简洁：

[Test]
[ExpectedException(typeof(System.DivideByZeroException))]//发生DivideByZeroException时，测试通过
public void Test1()
{
    int a = 0;
    int b = 1 / a;
    PrintConsole<object>.Print(b);
}

[Test]
[ExpectedException( "System.DivideByZeroException")]//发生DivideByZeroException时，测试通过

public void Test2()
{
    int a = 0;
    int b = 1 / a;
    PrintConsole<object>.Print(b);
}

[Maxtime]/ [Timeout]: 测试用例的最大执行时间，前者超时时不取消测试，而后者会强行中断，用法如下

[Test, Maxtime(2000)]

[Test, Timeout(2000)]

[Repeat]: 重复执行多少次，用法如下

[Test, Repeat(100)]

[RequiresMTA]/ [RequiresSTA]/ [RequiresThread]：测试用例必须的在多线程、单线程、独立的线程状态下运行，这三个我没有具体使用过，大家有兴起可以试试。

关于NUnit的Attribue就介绍这些，建议对此有兴起的网友，多关注其中数值类和平台类，或是修改NUnit的源代码，实现自己的Attribute，下文会有所介绍。

点此下载VS2010格式的示例程序，解压缩的DLL目录下有NUnit库，引用该库即可以运行。

本文链接

淘宝API开发系列---淘宝API的测试及使用

2012-02-09T15:55:00Z

在很久之前，由于对淘宝的API开发比较感兴趣，写了几篇关于淘宝API开发方面的随笔《淘宝API开发系列--开篇概述》和《淘宝API开发系列--商家的绑定》等文章，近期由于一客户需要一些淘宝API的例子，而我原来开发的例子已经过去两年了，之前我是基于一个中间组件top4net来进行开发的，这个模块就是在淘宝API SDK的基础上做了一些封装，不过原来的例子确已经不能运行了。

因此重新捡起行头，继续研究有啥变化的地方，不过发现虽然时间过去已经快两年了，淘宝API的使用模式，一直没有变化过，可能变化的就是API的一些细微的地方吧，因此这次，就摒弃了中间组件的方式，就直接使用淘宝官方提供的taobao-sdk-net.zip(http://dl.open.taobao.com/sdk/taobao-sdk-net.zip) 来进行开发，发现其实模式一样，操作也差不多而已，但是处理起来的细节有很多不同的地方。

为了进行淘宝的API开发，首先我们需要做下面几件事情。

1）

开发者注册一个账号，

2）然后为每个淘宝应用注册一个应用程序键（App Key) 。

3）下载淘宝API的SDK并掌握基本的API基础知识和调用，具体可以参考论坛的信息（http://dev.open.taobao.com/bbs/forum.php ）里面的技术分享区等。

4）利用SDK接口和对象，传入AppKey或者必要的时候获取并传入SessionKey来进行程序开发。

5）利用淘宝平台的文档中心和API测试工具，对接口进行测试。从而了解返回信息，方便程序获取。

以上是一般淘宝API应用开发的关键流程，其中通过淘宝文档中心和API测试工具，进行概念了解和接口信息查询很重要。因为这些数据就是我们需要在逐步显示出来的。淘宝的API很多，不过都分为了好几个领域，慢慢就会了解深入了。

然后我们也可以通过淘宝平台的API测试工具来了解返回的数据信息，每个淘宝API最下面一般都有一个API工具的内容，如下所示。其中我们选择【API Tools在线测试工具】就可以测试返回的接口数据了。

对于以上这些淘宝API接口，不需要Session就可以访问的，就直接利用【系统分配】的内容就可以访问并获取到数据了。注意其中红色圈中部分即可。

对于有一些用户方面的私密数据，如交易数据，买入或者卖出的数据，我们就要自定义指定自己的SessionKey了，如下所示。

卖出的信息，也需要传入SessionKey的信息，在程序中处理，得到下面的结果。

本文链接

ASP.NET——反编译看前后台页面的父子关系

2012-02-09T15:02:00Z

新建了一个asp.net网站，我们会看到目录中有如下文件

我们会看到default.aspx以及后置代码default.aspx.cs。

为了学习讨论和大家的方便，可以先在default.aspx中插入一个input,在default.aspx.cs中插入查找dll路径的命令。如下

<body>
    <form id="form1" runat="server">
    <div>
        <input type="text" runat="server">
    </div>
    </form>
</body>

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        Response.Write(this.GetType().Assembly.Location);
    }
}

运行编译网站后，default.aspx.cs会编译成.dll文件，同时浏览器中会显示出dll的路径。我们用反编译软件Refleter打开这个dll。

展开左侧，我们就能看出来，

①default_aspx为原来的前台页面default.aspx；_Default为default.aspx.cs页面。

②default_aspx的Base Type为_Default；_Default的Base Type为system.web.UI.Page

我们可以得出：1>后置代码default.aspx.cs为default.aspx的父类；2>Page为default.aspx.cs的父类

我们再看右侧：

①从第一行可以看出default_aspx继承父类_default，并且实现了IHttpHandler接口。

如上就是，default.aspx和default.aspx.cs的关系。

而对于上面的接口，IHttpHandler，请见下一次详解。。。

本文链接

使用delphi 开发多层应用（八）客户端更新数据到kbmMW服务器

2012-02-09T14:32:00Z

上次写了从kbmMW服务器给客户端返回数据，我们实现了数据的查询功能，但是当客户端对数据进行了增加、更新、删除的操作，

我们必须把这些操作返回到服务器端，并对后台数据库进行更新。kbmMW 可以很方便的实现这一功能，今天就做一个更新数据到

服务器的例子。

还是在昨天的基础上，我们要把客户端的信息更新到服务器上，首先需要在服务器端的Tkbmqueryservice 设置允许客户端更新

的权限，如图

即把allowclient 开头的几个属性都设为True;

同时为了保证客户端可以插入数据，要设一下TkbmMWIBDACResolver的insertkeyfields 为 True.

这样服务器端就可以了，现在编译并运行。

在客户端，我们放置一个TDBNavigator 和一个按钮。如图

通过TDBNavigator 可以把对数据更改保存的客户端，再通过"更新到后台" 按钮把数据写到服务端。

同时，由于我们使用的是直接sql 语句读取数据的，因此，为了能够在服务器端更新数据，必须提供两个

参数，一个是tablename, 一个是keyfeilds. 所以我们更改一下读取数据的过程：

procedure TForm2.Button1Click(Sender: TObject);
 begin
    kbmMWClientQuery1.close;
  kbmMWClientQuery1.Query.Clear;
  kbmMWClientQuery1.Query.Add('select * from RSSJ');
  kbmMWClientQuery1.KeyFields:='XH';  // 设置主键
  kbmMWClientQuery1.TableName:='RSSJ';  // 设置表名
  kbmMWClientQuery1.Open;

end;

这样，我们就可以先读取数据，然后编辑数据，使用TDBNavigator 确认更改，最后再更新到后台服务器及数据库服务器，

kbmMW 会根据更改的delta 自动生成更新的sql 语句，然后写入数据库。把客户端的数据变化更新到后台非常简单，代码

如下：

procedure TForm2.Button3Click(Sender: TObject);
begin

   kbmMWClientQuery1.Resolve();
end;

下图为运行结果

为了更好的说明这个问题，我们再客户端分别作增加，更新，删除三个操作，然后更新到后台，

同时在服务器端使用devart 的dbmonitor 来检测一下，看看服务器是怎么生成sql 语句的。

通过这个检测，我们很清楚的可以看到各个操作的sql 都成功生成，并且顺利执行了。

今天我们完成了单表的更新操作，但是在实际开发中，经常遇见的是多表同时更新的事务操作，多个表要要么同时更新成功，要么全部滚回。

今天太晚了，我们下次再讲事务操作吧。

本文链接

Android官方开发指南翻译(1)-什么是Android

2012-02-09T14:15:00Z

开始我的翻译之旅，英文能力有限，肯定有很多不对的地方，欢迎拍砖！

什么是Android?

Android是一个移动手机的软件栈，它包括一个操作系统、中间件和关键应用程序。Android SDK提供了利用java语言在android平台上开发应用程序的必要工具和APIs.

特征

·应用程序框架能够被重用和更换的组件

·Dalvik虚拟机优化移动设备

·集成浏览器基于开源的WebKit引擎

·最优化的图形库由传统的2D图形库组成；3D图形是基于OpenGL ES 1.0规范（可以选择硬件加速）

·SQLite提供了结构化数据存储

·媒体支持包括传统的音频，视频和图像格式（MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, GIF）

·GSM电话（硬件相关）

·蓝牙,EDGE,3G和WIFI（硬件相关）

·摄像头,GPS,指南针和加速计（硬件相关）

·富开发环境包括一个模拟器，调试工具，内存与性能模型和一个Eclipse IDE插件

Android体系结构

以下图形展示了Android操作系统的主要组件。每个部分的更多详细情况将在后面涉及。

应用软件

Android携带了一组核心应用软件，包括一个邮件客户端，SMS程序，日历，地图，浏览器，通讯录等等。所有应用软件都是java语言编写的。

应用程序框架

Android提供了一个开放的开发平台，使开发者能够开发极为丰富和创新的应用软件。开发者可以自由利用硬件设备，存储单元信息，运行后台服务，设置报警，增加状态条提示等等很多很多。

开发者可以完全进入跟系统核心应用软件使用的相同框架APIs.这个应用程序框架被设计用于简化组件的重用。任意一个应用程序都可以发布自己的功能，而且其他程序也可以使用那些功能(必须符合框架的安全约束)。这个相同的机制允许用户替换这些组件。

所有应用程序是以一组服务与系统为基础的，包括：

·一组丰富可扩展的视图可以用来创建一个应用程序，包括lists,grids,text boxes,buttons,甚至一个内嵌的浏览器

·内容提供者可以使应用程序从其他的应用程序获取数据(例如联系簿)，或者共享它们自己的数据

·一个资源管理器为获取非代码资源（例如局部字符串，图形和布局文件）提供了条件

·一个通知管理器可以使所有的应用程序在状态栏中显示自定义的通知

·一个活动管理器可以管理应用程序的生命周期和提供一个通用的导航回退功能

想了解更过详情和应用程序的演示，请查看记事本教程

程序库

Android包括一组应用于Android系统各种组件的C/C++程序库。这些功能均通过Android应用程序框架对开发者开放。一些核心的函数库如下：

·系统C程序库-一个BS-派生于标准C系统程序库，为嵌入基于Linux的设备

·媒体程序库-基于视频软件的OpenCORE；这些程序库不但支持多种流行音频和视频格式的回放和记录，而且支持静态图片文件，包括MPEG4, H.264, MP3, AAC, AMR, JPG, 和PNG

·界面管理器-管理从各种应用程序中访问显示子系统和紧密复合2D和3D图层。

·LibWebCore-一个包含Android浏览器和内嵌网络视图的现代网络浏览器引擎

·SGL-基础2D图形引擎

·3D程序库-一个基于OpenGL ES 1.0 APIs的实现；这些程序库使用了3D硬件加速器(如果有这些)或者内置的高性能的3D软件光栅期

·FreeType-位图和矢量字体的渲染

·SQLite-一个可供所有应用程序使用的强大的轻量级关系数据库引擎

Android运行时

Android包括一组核心程序库，它提供了大多数功能可供java编程语言的核心程序库使用。

每个Android程序都通过Dalvik虚拟机的实例运行在自己的进程中。Dalvik可以被写入以便一个设备能有效的运行在多个虚拟机中。Dalvik虚拟机执行经过最小内存封装的Dalvik可执行格式(.dex)文件。虚拟机是寄存器，可以运行被java编译器编译的类，这些类已经被内置的dx 工具转换成了.dex格式。

Dalvik虚拟机依赖于Linux 内核的基础功能，例如线程和低级的内存管理。

Linux Kernel

Android依赖Linux 2.6版本的核心系统服务，例如安全性、内存管理、进程管理、网络栈和驱动模型。这个内核也在硬件和其他软件栈中充当了一个抽象层。

本文链接

读《.NET设计规范》之命名规范的总结

2012-02-09T14:07:00Z

《.NET 设计规范》是数千名微软精锐开发人员的经验和智慧，最终浓缩在这本设计规范之中。它指导着.NET Framework几个版本的开发，和微软windows操作系统的下一代API---WinFX开发。上面这些话是C#之父说的，不是我。它指导着微软内部开发规范，可见是一本非常好的书，而且博客园的其他大牛也推荐过的，是一本修炼内功的武功秘籍。

为什么需要命名规范？

1、提高框架的可用性，一致性。使的不同项目的开发人员使用同一个框架成为可能。大到一个Framework，小到一些控件(Grid)或者封装的库，他们中的API都是为其他开发者所使用的，固良好的命名很重要。就比如：.NET Framework它里面的命名，开发组就花费了大量的时间，大量的讨论，甚至非常高的代价去做，并认为是非常重要的。

2、增加代码的可读性。良好的命名可以是代码易于理解，从名字上面就可以大概知道它的功能，一目了然。使得开发人员相互的沟通更为畅通。如果一个人的代码写的非常规范，那么其他人在阅读或者维护的时候，就比较容易了，可见从命名规范上就可以看出一个人境界。

标示符的大小写规范

1、PascalCasing。随着Pascal（Turbo Pascal最初的设计师-Anders Hejlsberg-C#之父）编程语言的流行起来的大小写风格称为PascalCasing。它被用于除了参数名之外的所有标示符，每个单词的首字母都大写。如：ObjectContext,HtmlTag

2、camelCasing。这种大小写风格看上去就像一个驼峰。它仅仅用于参数的名字。除了第一个单词小写之外，其他单词首字母都大写。如：userName,htmlTag。

首字母缩写与单词缩写

像首字母缩写词（比InputOutput首字母缩写词为IO）为两个的，他们要么全部大写，要么全部小写,如IOStream，ioStream。但首字母缩写词的长度超过2个，则视为一个单词，如Html，Xml，html，xml等。

　　首字母缩写是将一个短语的首字母组成，而单词缩写仅仅把一个单词的长度变短。请尽量使用已经被世人认可的首字母缩写词，单词缩写尽量的不用，因为这样会降低可读性的。例如该书上给出一个例子，在.NET 框架中有Color.FromArgb方法，它是一个缩写过度的例子，Argb让人联想到是参数b，arg如果是argument的缩写，这显示不是API设计者的本意。在这里A表示的是alpha通道，所以如果设计成这样Color.FromAlphaRgb或许更符合规范。但.FromArgb API已经随框架中发布出去，就不能随便改了。

复合词

复合词应该视为一个单词。如endpoint，Endpoint，常见术语大小写，在这里列出容易写错的一些。Pascal\camel :Callback\callback、Email\email、Gridline\gridline、Hashtable\hashtable、Id\id、Namespace\namespace、Ok\ok、Pi\pi、SignIn\signIn、LogOn\logOn

单词的选择

1、要选择易于阅读的名字

2、要看重可读性，而不是更看重简洁性。如：GetWindow要比GetWin要好

3、不要使用下划线，连字符及其他任何既非数字字母的字符。

4、不要使用匈牙利命名法。匈牙利命名法是用一些前缀，比如uiCount表示无符号整数，intCount，在这里ui或者int的前缀。但我们在私有实例字段时候，可以考虑加上前缀m_，如m_count ，这样区别于其他成员，该私有实例字段暴露给外界使用属性，属性的命名采用PascalCasing。给私有静态字段加前缀s_,便于区分，这并不和上面的规范冲突，规范是人约定的，合适的变通，才是王道。对于现代的编辑器来说，将鼠标放在变量上面，就会提示出类型。

5、避免使用与广泛编程语言有冲突的标示符。

在为已有API新增版本命名时候，优先使用后缀来表示已有API的新版本。因为Intellisense会把它们的位置放的很近。或者考虑新的名字。

总结

1、除了参数用camelCasing之外,其他大部分都是PascalCasing命名约定。

2、标示符要使用有意义的名字。如GetLength比GetInt要好，不要嫌单词很长(有自动补全功能)，不要使用自创的单词一部分。

3、标示符的含义要比含有类型更为重要。如形参（string value）而不是（string str），在这里value表示一个值，而str表示出它的类型是string。在如foreach（string item in collection）{}中的item。

4、不要在变量名或者参数命中使用下划线。如果一个标示符中的单词可有可无，那还是去掉，这样简洁些。

5、模仿学习框架中的命名，如果你的代码和框架的代码无法区分时，那么你的代码就相当的牛X了

本为主要目的是让大家了解基本的命名约定，或者能帮助大家对命名规范有些重要的认识，就满足了。当然《.NET 设计规范》命名规范这章中，还有其他的一些规范，没有列出，请有兴趣的同学自己去看了，谢谢！文中描述如果有不妥之处，还请高手指出，我们共同进步，谢谢！

本文链接

Windows Phone开发之路(14) 加载位图

2012-02-09T13:06:00Z

除了文本之外，位图是Silverlight程序中最常见的对象之一，通常我们将其定义为与图形显示设备的像素相对应的二维比特(bit)数组。
　　Windows原生的位图文件的扩展名是bmp，但是近年它已不占主导地位，而压缩格式开始广泛流行。目前，3种最主流的位图格式为：

JPEG(Joint Photography Experts Group,联合图像专家组)
PNG(Portable Network Graphics，便携式网络图像)
GIF(Graphics Interchange File，图形交换文件)

Silverlight只支持JPEG和PNG格式。

加载本地位图

一，利用Silverlight中的Image元素加载本地位图

XAML代码：

<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
            <Image Source="images/photo.jpg"
                   Stretch="None"/>
</Grid>

注：Stretch="None"表示以原始尺寸显示位图
　　　　效果如图：

二，利用C#代码加载本地位图

XAML代码：

<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
            <Button Name="btnLoad" 
                    Content="利用C#代码加载本地位图"
                    HorizontalAlignment="Center"
                    VerticalAlignment="Top"
                    Click="btnLoad_Click"/>
            <Image Name="img"
                   Stretch="None"/>
</Grid>

C#代码：

public partial class MainPage : PhoneApplicationPage
    {
        // 构造函数
        public MainPage()
        {
            InitializeComponent();
        }

        private void btnLoad_Click(object sender, RoutedEventArgs e)//处理按钮单击事件
        {
            //Uri uri = new Uri("/SilverlightTapToLoad;component/images/photo.jpg", UriKind.Relative);//创建Uri对象，此时位图的Build Action为Resource。
            Uri uri = new Uri("images/photo.jpg", UriKind.Relative);//此时位图的Build Action为Content

            StreamResourceInfo resourceinfo = Application.GetResourceStream(uri);//调用Application类的GetResourceStream方法访问资源文件并返回StreamResourceInfo
            BitmapImage bmp = new BitmapImage();//创建一个BitmapImage对象作为数据源
            bmp.SetSource(resourceinfo.Stream);//调用SetSource方法获取资源中的流
            img.Source = bmp;//设置位图的数据源
        }
    }

效果如图：

操作手机图片库

下面的实例是利用PhotoChooserTask选择器查看手机图片库中的图片。

XAML代码：

<Grid x:Name="LayoutRoot" Background="Transparent">
        <Button Name="btnPhotoChooser"
                Content="图片选择器"
                HorizontalAlignment="Center"
                VerticalAlignment="Top"
                Padding="0,34"
                Click="btnPhotoChooser_Click"/>
        <Image Name="imgChooser"/>
</Grid>

C#代码：

public partial class MainPage : PhoneApplicationPage
    {
        PhotoChooserTask choosePhoto = new PhotoChooserTask();//创建一个PhotoChooserTask对象

        // 构造函数
        public MainPage()
        {
            InitializeComponent();

            this.choosePhoto.Completed += choosePhoto_Completed;//注册事件处理程序，获取选择器操作的结果
        }

        private void btnPhotoChooser_Click(object sender, RoutedEventArgs e)//处理按钮单击事件
        {
            choosePhoto.Show();//启动图片选择器
        }

        void choosePhoto_Completed(object sender, PhotoResult e)//事件处理程序,PhotoResult类表示通过调用PhotoChooserTask返回的图片
        {
            if (e.TaskResult == TaskResult.OK)//任务成功完成,TaskResult表示任务是否完成
            {
                CompleteChooserTask(e);//调用方法，显示图片
            }
        }

        protected void CompleteChooserTask(PhotoResult e)
        {
            var bmp = new BitmapImage();//创建一个BitmapImage对象作为Image元素的数据源。等价于BitmapImage bmp=new BitmapImage()
            bmp.SetSource(e.ChosenPhoto);//调用SetSource方法获取照片的数据流。
            this.imgChooser.Source = bmp;//设置Image元素的数据源显示图片
        }
    }

效果如图：

本文链接

net加密基础2-非对称加密

2012-02-09T12:31:00Z

非对称密码算法

非对称密码算法使用2个不同但在数学上却相关的密钥。用于加密数据的密钥不能用于解密。

非对称密码技术统称称为“公钥加密技术”，没有双方必要保密的单个密钥。

公钥加密技术只有一个必须由一方保密的私钥，第二个密钥就是公钥，任何想与他们通信的人都可以随意使用它。

安全web通信就是采用的这种技术。该技术可以用于电子商务。

非对称和对称的区别

对称加密和非对称加密的密钥类型分别是私钥和公钥。

对称加密使用的是私钥加密，也就是密钥只能是加密者和解密者知道，第3方不能知道。

而非对称加密情况完全不一样，非对称加密有2个不同的密钥，一个是公共的密钥，一个是私有的密钥，公钥是可以让外人知道的，因为公钥只用来加密数据，而私钥只能由解密方知道，只有私钥能解密！

官方的啰嗦！

公钥加密使用一个必须对未经授权的用户保密的私钥和一个可以对任何人公开的公钥。公钥和私钥都在数学上相关联；用公钥加密的数据只能用私钥解密，而用私钥签名的数据只能用公钥验证。公钥可以提供给任何人；公钥用于对要发送到私钥持有者的数据进行加密。两个密钥对于通信会话都是唯一的。公钥加密算法也称为不对称算法，原因是需要用一个密钥加密数据而需要用另一个密钥来解密数据。

经典的小红和小明

双方（小红和小明）可以按照下列方式使用公钥加密。首先，小红生成一个公钥/私钥对。如果小明想要给小红发送一条加密的消息，他将向她索要她的公钥。小红通过不安全的网络将她的公钥发送给小明，小明接着使用该密钥加密消息。（如果小明在不安全的信道如公共网络上收到小红的密钥，则小明必须同小红验证他具有她的公钥的正确副本。）小明将加密的消息发送给小红，而小红使用她的私钥解密该消息。

但是，在传输小红的公钥期间，未经授权的代理可能截获该密钥。而且，同一代理可能截获来自小明的加密消息。但是，该代理无法用公钥解密该消息。该消息只能用小红的私钥解密，而该私钥没有被传输。小红不使用她的私钥加密给小明的答复消息，原因是任何具有公钥的人都可以解密该消息。如果小红想要将消息发送回小明，她将向小明索要他的公钥并使用该公钥加密她的消息。然后，小明使用与他相关联的私钥来解密该消息。

在一个实际方案中，小红和小明使用公钥（不对称）加密来传输私（对称）钥，而对他们的会话的其余部分使用私钥加密。

NET中的非对称加密算法类
算法	抽象算法类	默认实现类	有效密钥大小(位)	默认密钥大小(位)
RSA	RSA	RSACryptoServiceProvider	364-16384	1024
DSA	DSA	DSACryptoServiceProvider	364-512	1024

注意：公钥加密算法使用固定的缓冲区大小，而私钥加密算法使用长度可变的缓冲区。公钥算法无法像私钥算法那样将数据链接起来成为流，原因是它只可以加密少量数据。因此，不对称操作不使用与对称操作相同的流模型。

所有的非对称加密算法都是由AsymmetricAlgorithm类派生。

非对称RSA加密算法

实际使用中很少直接用RSA类来实现加密算法，因为它们采用不进行填充的原始计算。而是使用RSACryptoServiceProvider实现类的加密和解密方法

public byte[] Decrypt(byte[] rgb, bool fOAEP);

public byte[] Encrypt(byte[] rgb, bool fOAEP);

创建个rsa算法的对象

RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

我们怎么获取公钥和私钥信息？

之前的对称算法可以获取算法的key和IV信息。

但是非对称算法不提供可以用于检索密钥信息的任何属性！如果需要保存密钥信息供以后使用，就只能用ToXmlString()方法输出密钥对的信息。

public override string ToXmlString(bool includePrivateParameters);

这个布尔参数如果设置为true，那么就会输出带私钥的xml，如果是false，那么就只输出带公钥的xml。

尝试输出完整的密钥对

rsa.ToXmlString(true)

----------------------------完整的密钥对信息-----------------------------

<Modulus>yvGBq09qcWhIi+u3UHGK0EH5zav018FVGM+BPiXK23nFZeRky9HLrOH9DP5Bc7NXyBxoE0MC3YmaG68tr6nHtLhI7

TVshAsfMX1E2BjTfLq1wHhcFwTJSvyNpwnR9NHMZsDE166XgRQ5vHkfFwBWvk7F8YVcACKp3Y6OcvAcp1s=</Modulus>

<P>7+9YUu/6SFlOW4RrON/Lie+bMSmOZB/wfqj9AAdmX+n8joPQ/WLA69/CtetzIZ6KIOkD2fd8MFiFrjoHSXmpUQ==</P>

<Q>2IgZma4hTV3EWFP3TXasajl23oRoLBeuWZldu+Q2pyeCwuBE6Mmp2aTbXauPGw3ptUAX/8pw0QyI/6i0b3wa6w==</Q>

<DP>F4AW45Czr/BnV1lh8yEgW3NHfQo38yCZup4soZsX8N8HKKJKjvbkNHYnKRBVp35SwyRvhyLRXB7fgRAX9J9g8Q==</DP>

<DQ>SSgCbje0rKznb2g+/37+1YzAqoFVqL//eeolDxwVkvf4Z9rZrUSlDBF0w/r4iI10znXvJc7Buv9fMfFPtPLbLQ==</DQ>

<InverseQ>pJ37e7nw8Joy2dmnrYf5urx88NQz1TBKZF/xGReSeTiBsbkugqkoHWvX6GoWV8TL7Gx9ZRmAma/rs3YWQbk00Q==</InverseQ>

<D>PrjbibW2wSwo183XTy54Z5sseIt/1brz8QIZALsvchu1jaNEH9ZMa7dAvWZLllXEeJ2G8QUR+qRPk+TVaug/RydliAPdf11h+7nnIoNOzk4LJtBFmNROPXTOLNwap+GJWIQM1Hd72V4kDiv1He3HUNLsLgGmUelDWekISUzrYOE=</D>

</RSAKeyValue>

上面的xml信息可以在我们需要使用的时候导入到算法里面。

只输出公钥信息

rsa.ToXmlString(false)

----------------------------只包含公钥信息-----------------------------

<Modulus>igBXA4/oLVLNP+r9jxdx1lLfqNNkSUOe0ApKql8/jmUGc/dIzSMF6bgBcvw5dBxXncYVXxrtk7

AEilemz8PQui07M0NbJ4IeGQzRcJJNlAsQJvGWTydaoH/xLm4I0wH13RG2V9

UjcOYPMOHBEapB4Flkst44qqclw8SVuh55OWk=</Modulus>

</RSAKeyValue>

一个简单的RSA例子

static void Main()
{
    Byte[] StrByte = Encoding.UTF8.GetBytes("我是明文");
    RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
    string str = RSAEncryptor(rsa.ToXmlString(false), StrByte);
    Console.WriteLine("密文：{0}", str);
    Encoding en = Encoding.UTF8;
    Console.WriteLine("明文：{0}", RSADecryptor(rsa.ToXmlString(true), Convert.FromBase64String(str), en));
    Console.Read();
}

public static string RSAEncryptor(string XMLKey, byte[] Str)
{
    try
    {
        RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
        rsa.FromXmlString(XMLKey);
        return Convert.ToBase64String(rsa.Encrypt(Str, false));
    }
    catch (CryptographicException e)
    {
        Console.WriteLine(e.Message);
        return null;
    }
}

public static string RSADecryptor(string XMLKey, byte[] Str, Encoding en)
{
    try
    {
        RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
        rsa.FromXmlString(XMLKey);
        return en.GetString(rsa.Decrypt(Str, false));
    }
    catch (CryptographicException e)
    {
        Console.WriteLine(e.Message);
        return null;
    }
}

如果给解密的RSA对象传输个不包含私钥的XML，那么就会异常了，

你可以讲上面调用解密的代码修改成下面这样，就能得到异常了

Console.WriteLine("明文：{0}", RSADecryptor(rsa.ToXmlString(false), Convert.FromBase64String(str), en));

使用参数来传递密钥信息

RSAParameters

RSACryptoServiceProvider有2个方法可以导出RSAParameters类型的参数对象。

在使用加密解密算法的时候我们就只需要传递RSAParameters对象

将上面的代码成使用RSAParameters

static void Main()
{
    Byte[] StrByte = Encoding.UTF8.GetBytes("使用RSAParameters");
    RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
    string str = RSAEncryptor(rsa.ExportParameters(false), StrByte);
    Console.WriteLine("密文：{0}", str);
    Encoding en = Encoding.UTF8;
    Console.WriteLine("明文：{0}", RSADecryptor(rsa.ExportParameters(true), Convert.FromBase64String(str), en));
    Console.Read();
}

public static string RSAEncryptor(RSAParameters KeyPar, byte[] Str)
{
    try
    {
        RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
        rsa.ImportParameters(KeyPar);
        return Convert.ToBase64String(rsa.Encrypt(Str, false));
    }
    catch (CryptographicException e)
    {
        Console.WriteLine(e.Message);
        return null;
    }
}

public static string RSADecryptor(RSAParameters KeyPar, byte[] Str, Encoding en)
{
    try
    {
        RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
        rsa.ImportParameters(KeyPar);
        return en.GetString(rsa.Decrypt(Str, false));
    }
    catch (CryptographicException e)
    {
        Console.WriteLine(e.Message);
        return null;
    }
}

使用容器存储CSP密钥

之前使用的导出XML密钥信息的做法并不妥当，推荐使用密钥容器。

有关密钥容器的更多信息，请参见位于 http://www.microsoft.com/china/msdn 上的 Platform SDK 文档中的“CryptoAPI”一节。

我们这里使用的密钥容器是CspParameters类，当我们创建个CspParameters对象时，会生成随机的密钥对信息。我们只需要使用这个对象，便能方便的把密钥信息传递给相关的加密解密方法。

不使用密钥容器创建2个不同的RSA对象

RSACryptoServiceProvider rsa1 = new RSACryptoServiceProvider();

string xml1 = rsa1.ToXmlString(true);

RSACryptoServiceProvider rsa2 = new RSACryptoServiceProvider();

string xml2 = rsa2.ToXmlString(true);

Console.WriteLine(xml1 == xml2);

输出False

使用密钥容器创建2个不同的RSA对象

CspParameters csp = new CspParameters();

csp.KeyContainerName = "MyCspParameters";

RSACryptoServiceProvider rsa1 = new RSACryptoServiceProvider(csp);

string xml1 = rsa1.ToXmlString(true);

RSACryptoServiceProvider rsa2 = new RSACryptoServiceProvider(csp);

string xml2 = rsa2.ToXmlString(true);

Console.WriteLine(xml1 == xml2);

输出True

RSA加密大数据对象

RSA算法的一个弱点是只能加密117字节数据，前面的实例都是比较小的数据。

所以加密大数据对象的时候我们只能使用分块加密，讲数据分成多次加密。

(注意RSA加密后的Byte数组长度固定为128，117和128都是在默认密钥大小下的规定，如果您使用的不是默认密钥大小，那么就会不一样)

解密的思维也是将加密后的字节数组分多次来解密，这里每次最大每次解密128字节数据。

static void Main()
{
    Byte[] StrByte = Encoding.UTF8.GetBytes("王祖贤（1967年1月31日出生），英文名Joey Wong，身高1.72米。出生于台湾台北市，祖籍安徽舒城。台湾出道后于香港发展之电影女演员。17岁时拍摄第一部电影《今年的湖畔会很冷》并获得金马奖三项提名。1987年以《倩女幽魂》一片开始走红于亚洲各地。2009年7月7日传王祖贤因感情不顺在加拿大削发为尼。王祖贤本人对此表示否认，王父也通过王祖贤干爹傅达仁否认传言。");
    Console.WriteLine(StrByte.Length);
    RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
    string str = RSAEncryptor(rsa.ExportParameters(false), StrByte);
    Console.WriteLine("密文：{0}", str);
    Encoding en = Encoding.UTF8;
    Console.WriteLine("明文：{0}", RSADecryptor(rsa.ExportParameters(true), Convert.FromBase64String(str), en));
    Console.Read();
}

public static string RSAEncryptor(RSAParameters par, byte[] Str)
{
    try
    {
        RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
        rsa.ImportParameters(par);
        //获取RSA最大加密的长度
        Int32 KeySize = rsa.KeySize / 8;
        Int32 BlockSize = KeySize - 11;
        if (Str.Length > BlockSize)
        {
            //分配加密次数
            Int32 EncryptIndex = 0;
            if (Str.Length % BlockSize != 0)//不能整除
            {
                EncryptIndex = Str.Length / BlockSize + 1;
            }
            else
            {
                EncryptIndex = Str.Length / BlockSize;
            }
            //分配存储已加密的byte数组，请注意下这里分配的大小
            //每次只能加密117长度的数据，但是每次加密117长度的数据要生成128长度的密文。
            Byte[] EncryptByte = new Byte[EncryptIndex * KeySize];
            for (Int32 i = 0; i < EncryptIndex; i++)
            {
                Byte[] Block = new Byte[BlockSize];
                if (i == (EncryptIndex - 1))
                {
                    //最后一次加密
                    Array.Copy(Str, i * BlockSize, Block, 0, Str.Length % BlockSize);
                }
                else
                {
                    Array.Copy(Str, i * BlockSize, Block, 0, BlockSize);
                }
                Byte[] Block1 = rsa.Encrypt(Block, false);
                //将加密过的Byte数组保存到EncryptByte中
                Array.Copy(Block1, 0, EncryptByte, i * KeySize, KeySize);
            }
            return Convert.ToBase64String(EncryptByte);
        }
        else
        {
            byte[] b = rsa.Encrypt(Str, false);
            return Convert.ToBase64String(b);
        }
    }
    catch (CryptographicException e)
    {
        Console.WriteLine(e.Message);
        return null;
    }
}
public static string RSADecryptor(RSAParameters par, byte[] Str, Encoding en)
{
    try
    {
        Byte[] Block1;
        RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
        rsa.ImportParameters(par);
        Int32 KeySize = rsa.KeySize / 8;
        Int32 BlockSize = KeySize - 11;
        if (Str.Length == KeySize)
        {
            return en.GetString(rsa.Decrypt(Str, false));
        }
        else
        {
            //这个变量用来记录所有解密后的Byte数组的长度
            Int32 Len = 0;
            //保存每次解密后的Byte数组
            List<Byte[]> list = new List<Byte[]>();
            //计算解密需要的次数
            Int32 EncryptIndex = Str.Length / KeySize;

            for (Int32 i = 0; i < EncryptIndex; i++)
            {
                Byte[] Block = new Byte[KeySize];
                Array.Copy(Str, i * KeySize, Block, 0, KeySize);
                Block1 = rsa.Decrypt(Block, false);
                Len += Block1.Length;
                list.Add(Block1);
            }
            Byte[] EncryptByte = new Byte[Len];
            for (Int32 i = 0; i < list.Count; i++)
            {
                Array.Copy(list[i], 0, EncryptByte, i * BlockSize, BlockSize);
            }
            return en.GetString(EncryptByte);
        }
    }
    catch (CryptographicException e)
    {
        Console.WriteLine(e.Message);
        return null;
    }
}

RSA的优点和缺点

优点

1.安全性高，几乎不会被攻破。

缺点

1.速度慢，数学原理复杂。

2.单次加密数据小，加密大数据处理复杂

作者：海不是蓝

博客：http://www.cnblogs.com/hailan2012/

邮箱：hailan2012@sina.com

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

本文链接

博客园_首页

[WCF REST] 通过ASP.NET Output Caching实现声明式缓存

深入理解JavaScript系列（20）：《你真懂JavaScript吗？》答案详解

Windows下创建XUL应用程序

高效程序员秘籍（10）：聚合个人全部邮箱

[Architecture Pattern] Singleton Pool 模式

淘宝API开发系列---淘宝API的测试及使用2

20丰富多彩的网页设计的灵感

SQLite学习手册(C/C++接口简介)

Sharepoint学习笔记—Ribbon系列-- 2. 在Ribbon中添加新Tab

【jquery版.net控件—dropdownlist】附源码，欢迎大家指点、指正、拍砖！！！

基于ArcGIS10.0和Oracle10g的空间数据管理平台十五（C#开发）-空间数据导出

深入浅出三层架构

代码剖析： 新建一个项目（Windows 窗体应用程序），再在根目录下新建3个文件夹，分别是Model,DAL,BLL。 在Model下添加一个Person类 在DAL下添加一个SQLHelper类和一个PersonDAL类。 在BLL下添加PersonBLL类

Person.cs代码如下： using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace 三层架构Demo.Model{ class Person { public int Id { get;set;} public int Age { get; set; } public string Name { get; set; } }} SQLHelper类，封装了数据库操作的方法：

NUnit之Attribue详解

淘宝API开发系列---淘宝API的测试及使用

ASP.NET——反编译看前后台页面的父子关系

使用delphi 开发多层应用（八）客户端更新数据到kbmMW服务器

Android官方开发指南翻译(1)-什么是Android

读《.NET设计规范》之命名规范的总结

Windows Phone开发之路(14) 加载位图

net加密基础2-非对称加密

代码剖析：

新建一个项目（Windows 窗体应用程序），再在根目录下新建3个文件夹，分别是Model,DAL,BLL。

在Model下添加一个Person类

在DAL下添加一个SQLHelper类和一个PersonDAL类。

在BLL下添加PersonBLL类