博客园_大道至简

ms sql 索引（一）

2011-12-16T03:07:00Z

索引的用途

索引的主要作用就是为加快检索的速度（效率）。主要是为查询。这里的查询包括表自身的查询，还包括连接查询。此外，sql的查询优化器（隐式的）也依赖索引，如果使用索引比不使用索引时效率高，那优化器就会选择使用索引。

索引可能极大提高检索的速度。

例如：图书馆的图书如果无序排放，则要找《水浒传》这一本书，极有可能会把所有书都翻一遍，当然也有可能会第一本书就是它。如果给图书馆的图书按书名分列于不同书架，以字母排序，那找到S列书架，然后找Sh，shu，shui，然后找在shui书架中再找hu，然后找zhuan，那么就会找到这本书。

索引的分类

索引分聚集（聚簇）索引和非聚集（聚簇）索引。

聚集索引：表中的数据的物理顺序与排序顺序相同，表中可建立且只可建立一个聚集索引（物理顺序）。聚集索引由索引页构成，索引页底层称为叶级，上层称为非叶级。叶级存放着实际的排序的数据，非叶级存放着排序的索引。以图书馆查找《水浒传》为例的示意图：

上图是个示意图，但不表示聚集索引的正确图。索引通过B-tree算法来实现，中文的意思是平衡树，不是二叉树。

非聚集索引：不在物理顺序上排列数据，而是通过排序指针，指针指向数据。

非聚集索引也由索引页构成，索引页底层称为叶级，上层称为非叶级。叶级存放着的排序的指向实际数据的指针，非叶级存放着排序的索引。

Ms sql存储结构

Sql server在存储时，为提高数据库性能，以盘区为单位向数据库分配空间。一个盘区为8个连续的页（Page）。页是数据库存储的基本单位。页大小为8K。一个盘区为8*8＝64K。页分为好几种页类型，例如：数据页，索引页，映射表页等。

例如：图书馆的图书以书架（页）为单位，每8个书架在一个小隔间（区）。

索引的参数

·FillFactor：设置创建索引时每个索引页的页级别中可用空间的比。用来设置索引页中预留的空间。它是填充因子，设置为100%，表示不留预留空间。对于只读表来说，可以设置为100%。设置填充因子的原因就是防止页分裂。

例如：假设图书馆的6号书架为S系统的书籍，现在摆满图书，则它的填充因子（度）为100%，那么如果图书馆新增加了一本书《三侠剑》，按索引来安排，则它应该放到6号书架，但6号书架已经满了，那么可以增加一个书架（页），这个书架可能挨着6号书架，但也有可能有一定距离，那么，在查找《三侠剑》时，就要求在两个书架中查找，可能6号书架中找不到，到新增加的那个书架去找，而这个书架离6号书架较远，影响了查找的效率。那么如果6号书架没有摆满，而是只摆了60本书（假设一本书为1%），那么填充因子（度）为60%。此时当添加《三侠剑》时，可以放到6号书架中，而不必再增加一个额外的书架。

·Pad_Index：设置创建索引时每个索引页的非页级别中的可用空间的比。它的值由FillFactor指定。

性能分析（简）

简单说明一下，详细说明在后篇说明。

·showplan_text：设置sql server不执行（on）sql语句，而返回如何执行语句的详细信息。须做为单独的批处理运行，且不能用在存储过程中。与它类似的还有showplan_all，它的信息更详细。

·statistics io：显示执行sql语句的磁盘活动量。

输出项	中文输出名	含义
Table	表	表的名称。
Scan count	扫描计数	执行的索引或表扫描数。
logical reads	逻辑读取	从数据缓存读取的页数。
physical reads	物理读取	从磁盘读取的页数。
read-ahead reads	预读	为进行查询而放入缓存的页数。
lob logical reads	Lob逻辑读取	从数据缓存读取的 text、ntext、image 或大值类型 (varchar(max)、nvarchar(max)、varbinary(max)) 页的数目。
lob physical reads	Lob物理读取	从磁盘读取的 text、ntext、image 或大值类型页的数目。
Lob read-ahead reads	Lob预读	为进行查询而放入缓存的 text、ntext、image 或大值类型页的数目。

·statistics time：显示分析，编译，执行sql语句花费的时间（毫秒）。

·DBCC：全名为数据库控制台命令，即DataBase Console Command。

命令类别	执行
维护	对数据库、索引或文件组进行维护的任务。
杂项	杂项任务，如启用跟踪标志或从内存中删除DLL。
信息	收集并显示各种类型信息的任务。
验证	对数据库、表、索引、目录、文件组或数据库页的分配进行的验证操作。

主要介绍几个：

DBCC ShowContig：显示指定的表或视图的数据和索引的碎片信息。这个命令在高版本sql中推荐由动态管理函数sys.dm_db_index_physical_stats代替。

Dbcc showcontig(表名（id）｜索引名（id）｜视图名（id）) with

对于with部分，常用的是tableresults，用于通过表格显示信息结果。

DBCC DbReindex：重建立索引。

本文链接

DesignPattern2s——（3）decorator

2011-08-30T03:20:00Z

装饰者，decorator，定义是：动态将责任附加到对象上，若要扩展功能，装饰比继承提供了更具弹性的的替代方案。

定义很简单，而且每个人大概都有个模糊的概念和理解，但装饰者到底是为解决什么问题的？什么情况下可以应用这种模式？它到底是怎么样的？

从定义上，可以找到几个关键词：动态，责任，附加，对象，扩展，弹性。

动态，表示它不是死的，固定的。

责任，这里指对象的功能，类的作用，例如，行为。

附加，表示它是一种次要的事物，要依附主要事物。

扩展，表示它不是封闭的。

弹性，物理上表示物体受到外力发生形变，除去外力后恢复原来状态。它指的是一个量因受到另一个量的变化而变化。如果一个量变化大，那它的量变化也大，反之则小。弹性大，那么它的可伸缩的空间就大。

从字面上联系现实世界来看，装饰可以说是人的着装打扮。人有很多种，也有很多个，服装和化妆品也有很多种，很多个。因为文化、环境、个人等因素的存在，所以着装打扮也不尽相同。一个人可以穿休闲服，可以带上一个墨镜，如果下雨的话，还可以带上一个雨伞，或穿上一件雨衣。这些都可以形容为是一种装饰，它灵活。一个人可以穿多种多样的衣服，可以画很多不同的妆（只要想），那么说明装饰是可扩展的，它扩展的是一个人的外在表现。当然也可以添加一块手表，一个墨镜，那么它可以看时间，可以遮挡强光（还可以改变外貌，使人更酷），那么现在就扩展了人的行为：可以看时间，可以在强光下长时间看。

如果是冬天，天气寒冷，那么人可以穿保暖性强的服装，如棉服；如果是夏天，天气炎热，那么可以穿薄点的，通气性好的服装，如Tshirt，或不穿。

环顾周围，可以发现很多对象，而且很容易的说出它们的属性，例如：杯子，房子，鼠标，笔，手机等。但把现实世界的对象抽象为软件中的类型和对象时，会发现，并不容易。面向对象的设计与现实世界的对象是映射的。那么现实中解决问题的方法和面向对象的设计中的各种原则，例如设计模式也是对应的。如果在面向对象的软件设计和开发过程中，把两者联系起来，会发现，一切都是那么的合情合理。

现在描述一个场景：一个有老师，工程师，小学生的环境下（话剧的化妆间），每个人的穿着不一样，有穿学生装的，有带电脑的，有带领带的等。他们都要通过化妆师来化妆打扮以适合各自的角色，假设他们都穿着内衣来进行化妆。那么学生要穿：学生装，红领巾，短裤；老师要穿：长衣衫，长裙，平底鞋，眼镜；工程师：tshirt，裤子，皮鞋，带电脑，带领带。

在化妆间，发现，这些学生装，红领由，电脑，眼镜等都是独自存在的，而不是来就带有的（假设）。那到哪个角色，就可以为这个角色以角色的特征来添加相应的衣服和配套用品。

穿是人的行为，老师，小学生，工程师都能执行这个行为。

装饰者的装饰对应的功能是主要和次要类中所共有的，在这个例子中，他们有共同的行为：穿。然后被装饰对象和装饰对象拥有相同的抽象，也就是具有同一个父类，那么才能可能利用多态来实现装饰（包装）。装饰者模式有一个要素：

被装饰者（主要的，人，小学生，工程师，老师）和装饰者（各种服装，配套用品，皮鞋，电脑，眼镜等）共同的接口：这里就是人，精确的说是人的行为：穿。而为这个穿行为，主要者：各种职业有基本的穿着行为。然后通过装饰各种次要者，来实现各种角色服饰的目的。其中服装和配套用品可以有很多种，它是灵活的。可以要哪种服装加哪种。

（一）基类：其中有主要和次要的共同接口行为：Dress

public abstract class Person
{
    public void Display()
    {
        Dress();
    }
    public abstract void Dress();
}

（二）装饰者

从基类继承，且类中有要装饰的对象：

public abstract class Decorator : Person
{
    protected Person _person;
    public Decorator(Person person)
    {
        _person = person;
    }
    public override void Dress()
    {
        throw new NotImplementedException();
    }
}

（三）装饰者实现

实现装饰者，做为各种服装，配套类。如长裙类。

public class Longuette : Decorator
{
    public Longuette(Person person):base(person)
    { }

    public override void Dress()
    {
        _person.Dress();
        Console.WriteLine("longuette");
    }
}

（四）被装饰实现

主要的实现，例如学生

public class Student : Person
{
    public override void Dress()
    {
        Console.WriteLine("student's");
    }
}

使用：

Person person = new Student();
TShirt t = new TShirt(person);
t.Display();

装饰者会把被装饰者包装起来。这个包装的过程就是在装饰者中保留了对父类的一个的引用，同时装饰者继承了父类，当对一个从父类派生的被装饰者进行装饰时，可以调用这个引用的功能，同时对同一功能来说，还要加上装饰者本身的这个行为，做为一种装饰存在。实现了功能的附加。

装饰者模式的前提是装饰者和被装饰者具有相同的父类型。

它的定义是这样的：定义一个共同的父类，然后定义一个装饰抽象类，从这个父类派生。这个装饰抽象类中，保留一个父类的实例引用。定义一个被装饰者，也从这个父类派生。

当使用时，把被装饰者实例传递到装饰者，从另一形式上说，装饰者包起了被装饰者的实例，那么在执行行为时，可以在执行派生的行为外，还能通过保留的实例引用使用被包装对象的这个行为。这样就完成了职责的附加，扩展了功能。

现在考虑一个场景：设计一块电子表，它有最基本的计时功能。然后，为了用于各种不同的用途，例如：潜水用，森林里用，黑夜用等，可以为它添加不同的接口行为。可以添加指南针功能，可以增加防水功能，可以增加夜视灯功能。它的可附加功能有很多，且各个附加功能可能多个使用。在这种情况下，可以设计为装饰模式。

首先，要抽象出主要和次要的共同父类，这里把电子表做为这个父类，且这个父类具有最基本的计时能力。

public class Watch
{
    public virtual void Capability()
    {
        Console.WriteLine("计时");
    }
}

其次，设计装饰抽象，把父类引用保留在这个类中，同时在构造时把被装饰者传给这个引用，以调用这个被装饰者的能力。

public abstract class WatchDecorator : Watch
{
    protected Watch _watch;
    public WatchDecorator(Watch watch)
    {
        _watch = watch;
    }
    public override void Capability()
    {
        _watch.Capability();
    }
}

然后设计多个装饰实现者，实现要附加的功能：防水，夜视，指南针。

public class Waterproof : WatchDecorator
{
    public Waterproof(Watch watch)
        : base(watch)
    { }
    public override void Capability()
    {
        _watch.Capability();
        Console.WriteLine("防水");
    }
}
public class NightSight : WatchDecorator
{
    public NightSight(Watch watch)
        : base(watch)
    { }
    public override void Capability()
    {
        _watch.Capability();
        Console.WriteLine("夜视");
    }
}
public class Compass : WatchDecorator
{
    public Compass(Watch watch)
        : base(watch)
    { }
    public override void Capability()
    {
        _watch.Capability();
        Console.WriteLine("指南针");
    }
}

Watch watch = new Watch();
watch.Capability();
Console.WriteLine("****************************");
//添加夜视和指南功能
watch = new NightSight(watch);
watch = new Compass(watch);
watch.Capability();

装饰，或其他模式，或面向对象的设计的原则等等，如果与真实世界联系起来，会发现它们一切都在情理之中，且有的或有时比真实的世界更理想。好比艺术，来源于生活，但高于生活。同样，这些优秀的经验来自于真实的世界，且有时还高于这个世界。

本文链接

DesignPattern2s——（2）observer

2011-08-26T09:29:00Z

场景：水加热器，如果水温到95以上时，加热器的警报器会响且水温显示屏会显示当前的温度。

实现一：加热行为时，如果水温（状态）发生改变，到95度以上，那会同时调用行为：警报和显示。

public class Heater
{
  int _temperature;
  public void BoilWater()
  {
    for (int i = 0; i < 101; i++)
    {
      if (i > 95)
      {
        _temperature = i;
        MakeAlert(_temperature);
        ShowMessage(_temperature);
      }
    }
  }
  public void MakeAlert(int iTemperature)
  {
    Console.WriteLine("alarm:"+iTemperature);
  }
  public void ShowMessage(int iTemperature)
  {
    Console.WriteLine("current temperature is:" + iTemperature);
  }
}

以上实现了这个加热器，现在的情况是：当加热时，且加热到95度以上，那么会调用警报行为和显示行为。如果现在加热器

要添加一个行为：水温到95以上时，要跳动Jump。那么要在这个类中添加这个行为，同时更改BoilWater。

通过观察者模式，可以不用修改BoilWater。当加热器水温到达95度以上时，会同时通知三个行为：警报，显示，跳动。

观察者模式包括：subject主题，也就是被观察者；Observer，观察者。它可以描述为一种订阅和发布关系。

在以上场景中，加热器是被观察者，而三个行为是观察者，它们都依赖于被观察者的状态信息；而加热器加热到95度，会调用这三个行为，构成了对这三个行为的依赖。

实现二：通过观察者模式实现加热器

先把行为：警报和显示分离开来。

public class Heater
{
    int _temperature;
    public void BoilWater()
    {
        for (int i = 0; i < 101; i++)
        {
            if (i > 95)
            {
                _temperature = i;
            }
        }
    }
}
public class Alert
{
    public void MakeAlert(int iTemperature)
    {
        Console.WriteLine("alarm:" + iTemperature);
    }
}
public class Display
{
    public void ShowMessage(int iTemperature)
    {
        Console.WriteLine("current temperature is:" + iTemperature);
    }
}

警报器类和显示屏类中的行为都依赖于被观察者中的数据状态。观察者中的主题要求能够注册和注销这些行为。这里的注册注销可以动态添加这两个行为到一个行为集体，然后在执行到状态改变时同时调用这些行为。现在尝试把两个行为能够添加到一

个列表集合中。

把行为添加到集合列表

两个行为MakeAlert和ShowMessage除方法名不同外，签名的其它都相同。所以可以考虑通过委托列表集合来实现。

定义一个委托并修改主题：

public delegate void DelegateHeater(int iTemperature);
public class Heater
{
    List<DelegateHeater> _list = new List<DelegateHeater>();
    int _temperature;

    public void BoilWater()
    {
        for (int i = 0; i < 101; i++)
        {
            if (i > 95)
            {
                _temperature = i;
                Notify();
            }
        }
    }
    public void Notify()
    {
        foreach (DelegateHeater heater in _list)
            heater(_temperature);
    }
    public void Registe(DelegateHeater dheater)
    {
        _list.Add(dheater);
    }
    public void RegisteCancel(DelegateHeater dheater)
    {
        _list.Remove(dheater);
    }
}

使用加热器：

public void Test_5_heater_2()
{
    Heater heater = new Heater();
    //警报
    Alert aa=new Alert();
    //显示
    Display dd = new Display();

    //注册两个行为
    heater.Registe(new DelegateHeater(aa.MakeAlert));
    heater.Registe(new DelegateHeater(dd.ShowMessage));
    heater.BoilWater();

    Console.WriteLine("************************************");

    //显示器坏了，注销显示行为
    heater.RegisteCancel(new DelegateHeater(dd.ShowMessage));
    heater.BoilWater();
}

这样可以随意注册和注销加热器的行为。

现在实现了观察者模式，通过委托列表集合来保存注册的行为。委托类型可以把多个方法绑定到一个委托。在使用时，需要定

义委托类型实例，可以考虑把委托类型定义到主题（水加热器内部）并进行封装。

public class Heater
{
    public delegate void DelegateHeater(int iTemperature);
    public DelegateHeater _selfHeater;
    int _temperature;

    public void BoilWater()
    {
        for (int i = 0; i < 101; i++)
        {
            if (i > 95)
            {
                _temperature = i;
                _selfHeater(_temperature);
            }
        }
    }
}

去掉注册和注销的行为，通过添加到或删除从委托保存行为对象，然后通过调用委托，执行已经注册的行为。

public void Test_5_heater_2()
{
    Heater heater = new Heater();

    //警报
    Alert aa=new Alert();
    //显示
    Display dd = new Display();

    //注册两个行为
    heater._selfHeater += aa.MakeAlert;
    heater._selfHeater += dd.ShowMessage;
    heater.BoilWater();

    Console.WriteLine("************************************");

    //显示器坏了，注销显示行为
    heater._selfHeater -= dd.ShowMessage;
    heater.BoilWater();
}

访问类中的字段，通过采用属性方式访问。通过属性对域进行封装。它主要体现面向对象的封装特性，且可以提高安全性，和

数据的完整性。例如可以通过设置读和写属性来控制域的读写属性。但平时多从封装性方面来使用，在3.x及4.0版本中，出现了

自动属性。同样对于委托来说，可以通过事件类型来封装。

通过事件来封装委托实现水加热器。

public class Heater
{
    public delegate void BoilWaterHandler(int iTemperature);
    public event BoilWaterHandler BoilEvent;
    int _temperature;
    public void BoilWater()
    {
        for (int i = 0; i < 101; i++)
        {
            if (i > 95)
            {
                _temperature = i;
                BoilEvent(_temperature);
            }
        }
    }
}

调用时，和上一段实现没有区别：

public void Test_5_heater_2()
{
    Heater heater = new Heater();

    //警报
    Alert aa=new Alert();
    //显示
    Display dd = new Display();

    //注册两个行为
    heater.BoilEvent += aa.MakeAlert;
    heater.BoilEvent += dd.ShowMessage;
    heater.BoilWater();

    Console.WriteLine("************************************");

    //显示器坏了，注销显示行为
    heater.BoilEvent -= dd.ShowMessage;
    heater.BoilWater();
}

在加热器加热时，也就是在执行BoilWater时，如果温度到达95度以上，就会调用注册到BoilEvent事件的行为，它通过委托实现。但如果还没有注册行为，在BoilWater执行时，到达条件调用两个注册行为，会引发异常，因为现在BoilEvent未注册行为，所以，还应该在Heater类中BoilWater中添加对事件为空的判断。

if(BoilEvent!=null)
BoilEvent(_temperature);

现在通过委托且用事件封装委托实现了观察者。在c#中，事件的实现模式就是观察者模式。下面通过系统的自定义事件实现这个水加热器。

先看下常用的page_load事件

protected void Page_Load(object sender, EventArgs e)

可以知道，这个事件的委托类型委托的方法带两个参数： sender参数就是主题对象。而e为主题对象多个依赖的要获得的信息数

据，例如在热水器中，其中的温度就是这个e。

public class Heater
{
    public delegate void BoilWaterEventHandler(object sender, BoildEventArgs e);
    public event BoilWaterEventHandler Boiled;
    int _temperature;

    public void BoilWater()
    {
        for (int i = 0; i < 101; i++)
        {
            if (i > 95)
            {
                _temperature = i;
                if (Boiled != null)
                {
                    BoildEventArgs args = new BoildEventArgs(_temperature);
                    Boiled(this, args);
                }
            }
        }
    }
}

public class BoildEventArgs : EventArgs
{
    public BoildEventArgs(int iTemperature)
    {
        Temperature = iTemperature;
    }
    public int Temperature { get; set; }
}

public class Alert
{
    public void MakeAlert(object sender, BoildEventArgs e)
    {
        Console.WriteLine("alarm:" + e.Temperature);
    }
}

public class Display
{
    public void ShowMessage(object sender, BoildEventArgs e)
    {
        Console.WriteLine("current temperature is:" + e.Temperature);
    }
}

因为委托变了，所以还要调用被委托的行为的签名，所以ShowMessage方法和MakeAlert方法都做了相应的调整。

实现三：通过.net内置的观察者模式实现水加热器

在.net4.0中，添加了对观察者模式的支持。添加了两个接口：

IObservable<T>这个就是主题

IObserver<T>这个是观察者。

public class Heater:IObservable<int>
{
    List<IObserver<int>> _list = new List<IObserver<int>>();
    int _temperature;
    public IDisposable Subscribe(IObserver<int> observer)
    {
        _list.Add(observer);
        return observer as IDisposable;
    }
    public void BoilWater()
    {
        for (int i = 0; i < 101; i++)
        {
            if (i > 95)
            {
                _temperature = i;
                Notify(_temperature);
            }
        }
    }
    public void Notify(int iTemperature)
    {
        foreach (IObserver<int> observer in _list)
            observer.OnNext(iTemperature);

    }

    public IDisposable UnSubscribe(IObserver<int> observer)
    {
        _list.Remove(observer);
        return observer as IDisposable;
    }
}
public class Alert:IObserver<int>
{
    public void OnCompleted()
    {
        throw new NotImplementedException();
    }

    public void OnError(Exception error)
    {
        throw new NotImplementedException();
    }

    public void OnNext(int value)
    {
        Console.WriteLine("alarm:" + value);
    }

}

public class Display : IObserver<int>
{
    public void OnCompleted()
    {
        throw new NotImplementedException();
    }

    public void OnError(Exception error)
    {
        throw new NotImplementedException();
    }
    public void OnNext(int value)
    {
        Console.WriteLine("current temperature is:" + value);
    }
}

public void Test_7_observer()
{
    Heater heater = new Heater();
    Alert aa = new Alert();
    Display dd = new Display();

    heater.Subscribe(aa);
    heater.Subscribe(dd);
    heater.BoilWater();

    Console.WriteLine("************************************");
    heater.UnSubscribe(dd);
    heater.BoilWater();
}

Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。委托就是一种观察者模式的应

用，应用的前提是观察者（被委托的方法）具有相同的接口，或说具有相同的高层抽象。在这里被委托的方法，方法名可以

不同，但方法签名的其他部分相同。

本文链接

DesignPattern2s——（1）strategy

2011-08-25T07:34:00Z

先熟悉一下重要的概念：

面向接口编程

这里的接口指的不是狭义上的Interface，而是说抽象层次高的编程，也就是父类级。可以是普通类、抽象类、接口（interface）等。实现面向接口编程的基础就是多态。多态有好几种意义，但最常用，也是暗指的就是：父类的引用可以指向子类的对象实例。那么这种情况下此实例在不进行类型转换时表面上是一个父类型，所以只能访问父类中公开的属性和行为等成员；但实际上这个实例的类型是子类类型，进行类型转换后，除了继承自父类的成员外，还带有自己的成员。

public class Animal
{
  public void Show()
{
   Console.WriteLine("father");
}
}
public class Dog : Animal
{
  public void ShowMessage()
  {
   Console.WriteLine("son");
  }
}

Animal dog = new Dog();
dog.Show();
(dog as Dog).ShowMessage();
(dog as Dog).Show();

dog对象直接可见的成员是父类Animal中的Show方法。dog引用指向子类Dog的实例，进行转化后，除了可见继承自父类的Show方法外，还有它扩展的方法：ShowMessage方法。

这里要说的设计模式是策略模式。以headfirst中的例子来分析。

场景：一个模拟鸭子的游戏。鸭子有两种行为：叫和游泳。同时还有一个行为就是显示当前鸭子的信息。游戏中有两种鸭子：野鸭（mallard）和红头鸭（redhead）。

（一）通过继承实现

现在设计一个鸭子父类Duck，它包含三个方法：Quack（嘎嘎叫），Swim（游泳），Display（显示鸭子对象的信息）。这个父类的抽象层次较高，现在只知道它是鸭子，而不确定它是哪种鸭子。

两种具体鸭子：MallardDuck，野鸭子；RedheadDuck，红头鸭子。这两种鸭子都是会飞会游泳的，但它们的名称不一样，那么，在采用继承时，Display在子类中实现，而公共的行为：Quack和Swim在父类中实现。

因为这里有父类中有行为实现，那么可用抽象类来定义父类。

public abstract class Duck
{
  public void Quack()
  {
    Console.WriteLine("嘎嘎嘎 ~");
  }

  public void Swim()
  {
    Console.WriteLine("游泳 ~");
  }

  public abstract void Display();
}

//野鸭
public class MallardDuck : Duck
{
  public override void Display()
  {
    Quack();
    Swim();
    Console.WriteLine("一只野鸭子。");
  }
}

//红头鸭
public class RedheadDuck : Duck
{
  public override void Display()
  {
    Quack();
    Swim();
    Console.WriteLine("一只红头鸭子。");
  }
}

public void Test_1_strategy_1()
{
Duck duck = new MallardDuck();
duck.Display();
}

问题（一）：现在要为鸭子添加一种行为：飞

那么，当前系统中有两种具体的鸭子：野鸭和红头鸭，当然这两种鸭子都是会飞的，所以在父类中添加飞行为的实现即可。

public void Fly()
{
Console.WriteLine("飞 ~");
}

问题（二）：现在要增加一种鸭子种类：橡皮鸭（rubberduck）但它的叫不是嘎嘎的叫，而是吱吱的叫。

橡皮鸭通过继承父类实现了鸭子的所有行为：叫（嘎嘎叫），游泳，显示信息，飞。但这种鸭子是不会飞的。那么在这个子类中就多余了一种飞的成员。它不会飞，但却有飞的行为。如果多余一个飞的行为，那么在橡皮鸭的对象中调用飞的行为，那它就会飞了。

public class RubberDuck : Duck
{
    public override void Display()
    {
        Quack();
        Swim();
        Console.WriteLine("一只橡皮鸭子。");
    }
}

现在橡皮鸭的显示信息为：

嘎嘎嘎~

游泳~

一只橡皮鸭子。

现在更改橡皮鸭子的叫行为由原来的嘎嘎改为吱吱。这个可以通过虚方法的重写实现。

Duck父类：

public virtual void Quack()
{
Console.WriteLine("嘎嘎嘎 ~");
}

RubberDuck子类：

public override void Quack()
{
//base.Quack();
onsole.WriteLine("吱吱吱 ~");
}

现在显示信息为：

吱吱吱~

游泳~

一只橡皮鸭子。

还可以在不改变父类方法改为虚方法的情况下，通过new来覆盖继承的Quack方法：

public new void Quack()
{
Console.WriteLine("吱吱吱 ~");
}

那么这个fly行为当然也可以屏掉。

public new void Fly()
{ }

问题（三）：继续添加更多的鸭子种类，例如：诱饵鸭（木头做的），它不会飞也不会叫。

那么如果还用继承来实现，那这种鸭子会多出飞和叫行为，当然这些行为可以屏掉。

问题（四）：为鸭子添加跳舞行为

这里对于行为飞和嘎嘎叫来说，不是所有的子类都具有这两个行为，如果通过继承父类，那么所有的子类中都会有这些行为，那么这种方式不是适当的解决方式；把这两个行为从父类中分离开来，独立设置为行为接口，子类有哪个行为就实现哪个接口，通过这种接口继承，可以满足只有具有某个行为的子类真的只具有这个行为，但如果子类多了，那会造成大量的代码重复。

设计原则：分离出变化的部分。

上边已经提到了把飞和嘎嘎叫这两个行为分离开来，做为独立的接口存在，但在子类中不通过继承实现接口的方式来实现。

实现：

（1）分离出变化的行为

建立两个接口（interface），用以抽象两个行为。这里可以用抽象类，但对于行为抽象来说，接口（interface）更具有意义。

public interface IFly
{
void Fly();
}
public interface IQuack
{
void Quack();
}

在上边的IQuack接口中，行为叫是一个高层的抽象，它就是一个叫的行为，而不需要确定它是嘎嘎叫，所以，把这个接口改一下，用来表示叫行为（改个名字）：

public interface ICry
{
void CryOut();
}

（2）实现两种行为，建立行为类

public class FlyWithWings : IFly
{
  public void Fly()
  {
    Console.WriteLine("飞~");
  }
}
public class FlyNoWay : IFly
{
  public void Fly()
  {}
}
public class CryQuack : ICry
{
  public void CryOut()
  {
    Console.WriteLine("嘎嘎嘎 ~");
  }
}

public class CrySqueak : ICry
{
  public void CryOut()
  {
    Console.WriteLine("吱吱吱 ~");
  }
}

以上实现了飞和叫两种行为，飞的行为类有两种：能飞的和不能飞的；叫的行为类有两种：嘎嘎叫的和吱吱叫的。

（3）通过接口变量执行类的行为

在父类Duck中，设置飞行为和叫行为的变量，通过指向子类的实现，访问父类的成员。

public abstract class Duck
{
   protected IFly _fly;
   protected ICry _cry;
   public void PerformCry()
   {
     _cry.CryOut();
   }

   public void PerformFly()
   {
     _fly.Fly();
   }

   public abstract void Display();
}

（4）实现父类Duck的具体子类

//野鸭
public class MallardDuck : Duck
{
  public MallardDuck()
  {
    _fly = new FlyWithWings();
    _cry = new CryQuack();
  }
  public override void Display()
  {
    PerformFly();
    PerformCry();
    Console.WriteLine("一只野鸭子。");
  }
}

//橡皮鸭
public class RubberDuck : Duck
{
  public RubberDuck()
  {
    _fly = new FlyNoWay();
    _cry = new CrySqueak();
  }

  public override void Display()
  {
    PerformFly();
    PerformCry();
    Console.WriteLine("一只橡皮鸭子。");
  }
}

现在，在鸭子子类的构造器中，对行为进行了实例化，确定了行为的具体实现。野鸭类中的叫这里设置了具体的嘎嘎叫行为，但说不定会因为某些原因（受伤）而叫不出声音或叫出嗷嗷叫的声音，那么在这里可以由具体实现提升到对接口编程。改造一下：

public class MallardDuck : Duck
{
  public MallardDuck()
  {
  }

  public MallardDuck(IFly fly,ICry cry)
  {
    _fly = fly;
    _cry = cry;
  }
  public override void Display()
  {
    PerformFly();
    PerformCry();
    Console.WriteLine("一只野鸭子。");
  }
}

//橡皮鸭
public class RubberDuck : Duck
{
  public RubberDuck()
  {
  }
  public RubberDuck(IFly fly, ICry cry)
  {
    _fly = fly;
    _cry = cry;
  }
  public override void Display()
  {
    PerformFly();
    PerformCry();
    Console.WriteLine("一只橡皮鸭子。");
  }
}

那么这时，即使将来野鸭子的叫行为发生改变，那也可以通过设置另一种叫的行为类来改变叫的行为，而不需要改变子类的实现代码。

Duck duck = new MallardDuck(new FlyWithWings(), new CryQuack());
duck.Display();

飞~

嘎嘎嘎~

一只野鸭子。

看以上代码，发现对于两个参数的构造器来说，代码实现都是相同的，那这部分代码就重复了，可以移到父类中实现。

public Duck(IFly fly, ICry cry)
{
_fly = fly;
_cry = cry;
}

public MallardDuck(IFly fly, ICry cry): base(fly, cry)
{}

策略模式

定义了算法家族，算法间可以互相替换，算法的变化独立于使用它的客户。

这里所说的算法指的就是上面的行为接口。

总结：策略模式是行为类设计模式，用于封装算法家庭，通过多态实现算法间互换和独立于使用客户。

本文链接

Ruby入门（4）——类

2011-08-10T08:55:00Z

创建类： class后跟类名，其中类名的首字母必须要大写。实例化时，通过new方法实例化。在c#中有构造器，构造器与类同名。在ruby中，构造器为initialize方法。当通过new方法实例化一个类对象后，会自动调用initialize方法，把new中的参数传递给initialize方法进行初始化。在c#中的域，在ruby中称为实例变量，定义时前边加@前缀，表示是一个实例变量。

class Customer
    def initialize(name,age)
      @name,@age=name,age
    end
end

c1=Customer.new("Tom",20)

访问器

实例变量只能通过实例方法来访问。如果要访问它们可以提供方法访问器。在c#中称为属性，Java中也是定义方法来表示属性。

class Customer
    def initialize(name,age)
      @name,@age=name,age
    end

    def name
      @name
    end
    def age
      @age
    end
end

以上定义了两个方法x，y，它们可以读@x，@y实例变量。这就定义了读属性方法。如果要进行赋值操作，还要定义写属性方法：

    def name=(v)
      @name=v
    end
    def age=(v)
      @age=v
    end

要注意的是：

c1=Customer.new("Tom",20)
c1.name="Jhon"

只有在实例中才能这样使用写属性。如果在类中，不能通过name=value这样来代替@name=value。但可以通过self来这样使用：self.name=value

Ruby提供了简化定义属性方法：attr_reader和attr_accessor。后边跟符号，会自动创建同名的读写属性。

class Customer
    def initialize(name,age)
      @name,@age=name,age
    end

    attr_reader :name,:age
    attr_accessor:name,:age
end
c1=Customer.new("Tom",20)
puts c1.name,c1.age
c1.name="Jhon"
c1.age=30
puts c1.name,c1.age

类变量，常量，类方法

类变量以@@开头；常量通过[类名+::常量名]进行访问；类方法在实例方法方法名前加类名。在定义类方法时，可以采用一种方式：

class<<self

def 方法

end

那么，这个方法就是一个类方法：

class Customer
    def initialize(name,age)
      @name,@age=name,age
    end
    class <<self
      def showName
        'ok'
      end
    end
end

puts Customer.showName

方法的访问性

public：公有的，默认情况下类中的方法是公有的，可以用在任何地方。构造方法initialize为私有的。

private：私有的，类内部使用的，只能被类或子类的实例方法所调用。只能通过self隐式调用，不能通过一个对象显示调用。一个私有方法m，只能通过m调用，而不能通过o.m或self.m调用。

protected：受保护的，类内部或子类内部使用的方法。与私有的区别是：除self隐式调用外，还可以通过该类对象显示调用。

可以通过以下方法来声明方法的访问性：

#访问性 private protected public
  private
  def private_method
    puts "private method testing"
  end
  protected
  def protected_method
    puts "protected method testing"
  end

  public:protected_method

工厂方法

使用new方法私有，然后通过类方法创建实例

class Fruit
  private_class_method:new
  def Fruit.CreateFruit
    new Fruit
  end
end
f=Fruit.CreateFruit

模块module

module作用之一是做为名字空间用。调用类时与调用常量相同：两个冒号

另一作用是作为混入。通过include把模块中的实例方法包含到其它类中。感觉功能像C#中的名字空间引入。

本文链接

Ruby入门（3）——方法、代码段

2011-08-08T08:56:00Z

Ruby中的方法是一个有名称的代码块，是与一个或多个对象关联的参数化的代码。调用时须给出方法名，接收者（所在对象），参数值，且最后一个表达式的值做为返回值。与Ruby方法相似的是代码块，它没有名字，且调用时只通过迭代器或被间接调用。

（一）方法

（1）定义方法

定义方法就是

def 方法名（参数列表）

方法体

end

最后一个表达式做为返回值返回，如果有值，则返回；无值则返回nil。可以省略return。

在类中定义的方法为实例方法，实例方法可以在类的实例对象上使用。如果是在一个特定的对象上定义方法，那么此方法就是一个单键方法，只能在这个对象上使用。

class Test
  def instance_method_test(v)
    puts "#{v}: instance method"
  end
end

t1=Test.new
t2=Test.new
t1.instance_method_test("t1")
t2.instance_method_test("t2")

def t1.singleton_method_test(v)
  puts "#{v}:singleton method"
end

t1.singleton_method_test("t1")
#t2.singleton_method_test("t2")

在ruby中，方法一般小写字母开头，如果超过一个单词，则由下划线隔开（看习惯）。有意思的是方法名可以以等号、问号、叹号结尾，且有不同的意义：以等号（=）结尾表示这是一个赋值方法（写属性）；以问号（?）结尾表示一个断言方法，可以回答调用者提出问题的值，例如判断大小；叹号（!）结尾表示是一个可变方法，可能会影响到对象的状态，要小心使用。这三个符号很有意思，但它们不是必须的。

（2）取消方法

通过undef 方法名可以取消方法。对于被继承的方法，undef可以取消子类中的继承来的方法，但不会取消父类中的此方法。

（3）方法参数

在参数中添加等号和值就可以为这一个参数设置默认值。如果参数有默认值，那么在调用方法时，可以为这个参数指定值或不指定值。

def createRole(name,level=1)
puts "role name is#{:name} level is #{level}"
end

createRole("way")
createRole("clound",5)

通过在参数前边加星号（*），可以为方法指定为可变参数个数（数组参数），且指定的个数最多为一个。

def add_Person(*users)
puts users
end
add_Person("a1","a2")
add_Person("a1","a2","a3")

如果要把数组传递给方法，要在数组前加星号（*）。

（二）代码块

方法调用后可以紧跟一个代码块，关联代码块的方法可以通过yield来调用。

def showMessage(i)
yield i*2
print i
end

showMessage(5){|x|print "#{x}"}

代码块通过yield调用，也可以做为方法参数传递，但前提是这个参数前需要添加&做为前缀且为最后一个参数。而此时它以一个proc对象传递，调用时不能通过yield调用，而是通过proc的call方法调用。另外，如果以显示方式，即传递proc对象给方法，那方法定义的参数就不加&前缀了。通过&前缀，代码块可以与任何方法调用关联起来，即使此方法没有yield语句。任何方法调用都可以用&参数作为最后一个参数。所有支持to_proc的方法都能用&。

#传递代码块，代码块参数须为最后一个，且添加&前缀；且调用时用proc的call方法
def fun_block(i,&b)
b.call(i*2)
end
fun_block(2){|x|puts x}

#显示传递proc对象。那么方法中proc对象部分的参数不加&前缀
def fun_proc(i,b)
b.call(i*2)
end
p=Proc.new{|x|puts x}
fun_proc(2,p)

c=[1,2,3,4,5,6]
b=c.select{|x|x%2==0}
p1=Proc.new{|x|x%2==0}
d=c.select(&p1)
puts d

代码块是Ruby的一种句法结构，不是对象，但可以创建对象来表示一个代码块。根据对象的创建方式，分为proc或lambda。proc行为与代码块相似；lambda行为与方法相似，但它们都是Proc类的实例。

通过Proc.new创建一个proc，在1.9版本中，与proc方法为同义词；通过lambda方法，创建一个lambda。lambda方法不带参数，调用时段关联一个代码块。

在ruby 1.9中，支持一种新的句法。将lambda换为->；将参数放到花括号外边，小括号里边；花括号中只保留表达式。（可以与.net3.*中的lambda比较：()=>{}）

#1.8k中
d1=lambda{|x|x+1}
puts d1.call(5)
#1.9中，将lambda换为->；参数放到花括号外边，小括号里边；花括号中只保留表达式
#与.net3.*中的lambda表达式很像()=>{}
d2=->(x){x+1}
d2.call(5)

这种新句法，使代码简洁，并使代码段与ruby方法的统一，例如：设置参数默认值。

（三）闭包

ruby中的proc和lambda都是闭包（closure）。闭包表示一个对象既是一个可调用的函数，同时也是绑定在这个函数上的一个变量。从表面上解释闭包就是：方法A内的方法B调用方法A的变量，并返回结果。方法B就是闭包。它的作用：一是B方法的变量可以在方法外使用；二是A方法中的变量可以安全使用；三是对B方法中的值进行缓存。

（关于闭包，可以查看相关文档，我这里只是粗浅的认识。）

本文链接

Ruby入门（2）——基本流程控制

2011-08-08T05:41:00Z

（一）条件判断

条件判断为基本式：

if expression

code

end

表达式如果不是false或nil，则可执行code部分，所以对于else来说，如果为false或nil，则else下的代码是要执行的。要注意的是表达式与执行代码之间要有分界符：例如换行或分号或是then关键字。

多条件分支情况下，除了可以用else if之外，可以用省略式：elsif

if expression1

code1

elsif expression2

code2

else

code3

end

如果通过then做为分界符：

if expression then code end，那么可以把if直接做为分界符：code if expression，这时，if称为表达式修饰符。先写执行再写执行条件。要注意的是：如果成为表达式修饰符，则执行代码与if之间不能带换行符。虽然这种方式也是一种条件句，但我觉得它更像一种修饰。

对于if判断来说，它可以返回执行代码后的值。

与if条件类似，还有unless判断，它和if相反。

在C#中，多分支语句有个switch case开关，在ruby中，则是case when。case when非常灵活。

（二）循环

循环条件是while do或until do，而位于它们之间的是循环体。

现条件if相似，循环语句也可以用分界符的形式做紧凑循环，这时，省略了换行符和end。

x=1
puts x,x+=1 while x<10

while x<20 do
puts x
x+=1
end

在C#中有for循环应用非常广泛，在ruby中，for循环与foreach的作用类似，用于对可枚举对象进行迭代。

for var in collection do

code

end

其中collection是带有each迭代方法的对象；do关键字可选（可以用换行符或分号替代）。

arr=%w[1 2 3 4 5 6]
for item in arr
print item<<" "
end

hash1={:a=>1,:b=>2,:c=>3}
for key,value in hash1
print "#{key}=#{value}"<<" "
end

（三）迭代器和枚举

除了循环控制while、for、until外，有种特殊的方法用于循环，也就是迭代器，它是ruby最重要的特性之一。

（1）数值迭代器

upto：为一个区间内的所有整数调用其关联的代码块。左边为起始，右边为结束。

downto：与upto相反。

times：调用关系的代码一定的次数，且把0到n-1传递给代码。

step：以一定的步长，迭代增加到指定数值。第二个参数为步长。

1.upto(5){|x|print "#{x} "}
puts
5.downto(1){|x|print "#{x} "}
puts
3.times{|x|print "#{x} "}
puts
3.step(5,0.5){|x|print "#{x} "}

（2）枚举迭代器

each：将迭代元素传递给代码。

collect：为调用它的枚举的每个元素执行关联代码后，组合到一起做为一个数组返回。

select：为调用它的枚举的每个元素执行关联代码后，如果为真，组合到一起做为一个数组返回。

reject：与select相反。它把为false或nil的元素做为一个数据返回。

inject：求累积值迭代。通过两个参数调用关联代码块，第一个参数是前次调用代码块的累积值，第二个参数指调用进行迭代的下一个元素。如果有传递参数，则做为第一个参数的初始值，如果没有，则把第一次进行迭代的元素值做为初始值。

a1=[1,2,3]
a2=a1.map{|x| x+1}
a3=a2.collect{|x| x+1}
print a2,a3

#o偶数
a5=a1.select{|x|x%2==0}
print a5

a6=a1.reject{|x|x%2==0}
print a6
puts
a7=a1.inject{|sum,x|x+sum}
puts a7
a8=a1.inject(10){|sum,x|x+sum}
puts a8

本文链接

Ruby入门（1）——数据类型

2011-08-04T09:12:00Z

（一）数值类型

（1）整型

整型分两种，如果在31位以内（四字节），那为Fixnum实例。如果超过，即为Bignum实例。

#整型 Integer 以下是一些整型字面量
#字面量（literal）：代码中能见到的值，数值，bool值，字符串等都叫字面量
#如以下的0,1_000_000,0xa等
a1=0
#带千分符的整型
a2=1_000_000
#其它进制的表示
a3=0xa
puts a1,a2
puts a3
#puts print 都是向控制台打印字符，其中puts带回车换行符
=begin
这是注释，称作：嵌入式文档注释
类似C#中的/**/
=end

（2）浮点型

#浮点型
f1=0.0
f2=2.1
f3=1000000.1
puts f3

浮点有个圆整错误，例如：0.4-0.3＝＝0.1

这是不等的。C#中也是如此（采用IEEE－754浮点的都是如此）。因为很多浮点数是用一种近似值来表示的。例如0.1，它只是无限接近0.1。因为0.1不能用二进制精确表示。但0.5可以。

puts 0.3-0.2==0.1 #false
puts 0.8-0.3==0.5 #true
puts 0.8-0.7==0.1 #false

（3）算术操作

加减乘除操作符：+-*/；指数操作符为**

指数不必是整数，例如

#指数算术
puts 2**(1/4)#1与4的商为0，然后2的0次方为1
puts 16**(1/4.0)#1与4.0的商为0.25（四分之一），然后开四次方根

（二）字符串类型

字符串型可以用单引号或双引号表示。两种表式方法双引号推荐使用：双引号转义字符全；双引号中的字面量可以包含表达式。

字符串内插格式为：#{}

name="Ruby"
puts name
puts "#{name+",ok"}"

字符串分界符

可以通过字符串分界符来定义字符串字面量。

%q用于单引号规则

%Q用于双引号规则

分界符成对出现的，例如：()，[]，{}，两个！！。如果使用！做为分界符，其中字面量中又出现了！号，那么，需要\!来转义。当然，如果其中的字面量中出现了成对的分界符（其实是做为操作符出现的），那不需要转义的。

#分界符
s1=%Q[this ''/ssss123]
puts s1
#字面量中有分界符，一般情况下要做转义操作
s2=%Q!this ''/ssss123\!\!!
puts s2
#字面量中有成对的分界符出现，可以不做转义
s3=%Q(2*(1+1))
puts s3

在大字符串字面量中，不可保证分界符不出现。在ruby中支持header document。即通过定义分界字符串来定义字面量，可大大保证成功率。

通过<<或<<-紧临header 来定义，且结束段单独一行。如果通过<<-来定义的，则结束行前可加空白符。例如：

#分界字符串
s1=<<Header
sdfie''''//////[]
Header
puts s1

字符串操作

（1）用+号进行字符串连接。对于不是字符串的需要to_s方法进行显示转换，才能用于连接。注意的是，连接后的字符串会新建一个对象返回。

（2）用<<号进行字符串连接。此操作符连接字符串，是修改左侧字符串，而不新建对象。

（3）用*号表示重复左侧字符串，

（4）字符串截取

通过[]来访问字符串中的子字符串。字符串可以作为字符数组来看待。如果索引为负数，则从右向左取字符。（在1.8和1.9中通过[]访问返回的不同，1.9中取的更符合习惯）

通过[]索引访问进行赋值操作，可以替换字符。

通过[]中两个值进行访问，可以截取子字符串

（5）通过range截取子字符串。

通过range表示的两个都是索引，这个区别于[]中以逗号分隔的一个用于索引，另一个用于长度。

[..]或[…]

其中两个点的为包含区间。

（5）通过索引字符串，来判断包含关系

通过[“字符串’]来判断是否包含此子字符串

（三）字符类型

字符类型通过？+字符来定义。

（四）数组

数组字面量通过[]中以逗号分隔定义，且支持range定义。同时，数组字面量引用同%q，%Q类似的%w，%W分界符。中间以空格分隔。

（1）数组通过[]索引访问

同字符串相似，数据通过索引进行访问。如果有两个数值，则一个表示索引，另一个表示元素个数

（2）通过赋值操作插入、删除、替换元素

（3）通过+，－号进行合并和删除元素，且集合做为新集合出现

（4）通过<<号向原数据追加元素

（5）通过*号重复数组元素

（6）通过｜和&符号做并集和交集操作（注意顺序）

（五）哈希类型

哈希字面量由逗号分隔的kv对来定义，被包括在花括号之间，kv对以=>来定义

#hash
h1={"a1"=>1,"a2"=>2}
h2={:a1=>3,:a2=>4}
h3={a1:5,a2:6}

puts h1["a1"]
puts h2[:a1]
puts h3[:a1]

（六）范围类型

通过..或…符号定义范围类型，它有顺序性。

（七）true，false，nil

比较nil值，可以通过：

Ojb==nil或

Obj.nil?

（八）对象标识、对象的类、类型

对象标识在1.9中可以通过：

__id__得到，或object_id

对象的类：

Obj.class==String或

Obj.instance_of? String

x1="ok"
puts x1.class==String
puts x1.instance_of?String

判断是不是一种类型的实例也可通过：is_a?或===

x1="ok"

puts x1.is_a?String
puts x1===String

（九）对象冻结、污染

通过freeze冻结对象，被冻结对象将不可变（所有内部状态都不可变）。如果类被冻结，则类不能添加方法。

通过taint污染对象，被污染的对象会成为污染源（源自它的对象都是被污染的）。通过untaint进行解除污染。

本文链接

CSP加密服务（一）

2011-03-31T04:10:00Z

（一） 加密服务提供程序

缩写为：CSP，全称为：Cryptographic Service Provider 即加密服务提供者。它是windows系统中提供的用于加密的软硬件组件。通过对微软的加密应用程序接口即CrytoAPI（或CAPI）的编程访问它来提供身份验证、编码和各种的加密、签名算法。

如下图：

应用程序不是直接与某个CSP通信。它会调用 CAPI的函数，然后操作系统通过CrytoSPI（一个系统接口）筛选这些调用并且把这些调用传递到适合的CSP函数。然后CSP通过对参数的解析调用适当的CSP函数，最后向操作系统返回期盼值（加密操作是由特定的CSP来完成的）。

每个CSP是实现全部加密操作的独立模块。每个应用程序中至少需要一个CSP完成加密操作。对于使用多个CSP的情况下，在加密函数调用时需要指定CSP。当然基本加密服务是默认绑定到CAPI的。每一个CSP对CAPI提供不同的实现，例如某些实现了对硬件的支持。

CSP有多种类型，且数目在增加中，以下列举几种：

Microsoft Base Cryptographic Provider

Microsoft Strong Cryptographic Provider

Microsoft Enhanced Cryptographic Provider

Microsoft AES Cryptographic Provider

Microsoft DSS Cryptographic Provider

……

CAPI的功能：向应用开发人员提供对基于windows的应用程序添加验证、编码和加密的能力。

CryptoSPI的功能：将CryptoAPI的调用传递给CSP，可以理解为使用CSP。

（二） CryptoAPI

全称：（Microsoft）Cryptography Application Programming Interface即（微软）加密应用编程接口，也缩写为：CAPI。

CAPI提供一套安全相关的函数集合，用于加密、摘要、数字签名等。

（三） 密钥存储区

密钥可以保存在磁盘、内存或硬件密钥存储区中。

例如：可以以文件的形式保存在磁盘中或保存在密钥容器中；也可以保存在例如智能卡硬件的密钥存储区中。

（四） 公钥加密Windows密钥库

Windows系统提供两种密钥存储类型（级别）：

用户级别：User key store

存储在特定用户的 Windows 用户配置文件中

计算机级别：machine key store

对于所有可以登录到计算机的用户都可用，而且可以使用 ACL 限制对加密密钥信息的访问权限

（五） 密钥容器

Key container。密钥容器是保存密钥的最小单位，包含了密钥和其它信息。

（六） .net中的CSP

在.net中，以CryptoServiceProvider结尾的类是相应的 CSP 的托管代码包装类，即实现加密服务的提供者，名字空间：System.Security.Cryptography。

以TripleDESC私钥加密为例：

public void Test_7_TripleDES()
{
    string strContent = "123aaa";
    string strKey = "qwuduII*6&*%^&(90))";

    TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();

    MD5CryptoServiceProvider hashMD5 = new MD5CryptoServiceProvider();

    DES.Key = hashMD5.ComputeHash(Encoding.UTF8.GetBytes(strKey));

    DES.Mode = CipherMode.ECB;

    ICryptoTransform DESEncrypt = DES.CreateEncryptor();

    byte[] Buffer = Encoding.UTF8.GetBytes(strContent);

    byte[] sipherbytes= DESEncrypt.TransformFinalBlock(Buffer, 0, Buffer.Length);

    Console.WriteLine(Encoding.UTF8.GetString(sipherbytes));

    ICryptoTransform DESdecrypt = DES.CreateDecryptor();

    byte[] plainbytes = DESdecrypt.TransformFinalBlock(sipherbytes, 0, sipherbytes.Length);

    Console.WriteLine(Encoding.UTF8.GetString(plainbytes));
}

（七） .net中的CspParameters类

CspParameters类，名字空间为：System.Security.Cryptography，表示可从非托管CrytoAPI传递到内部使用加密服务提供程序CSP的托管加密类的参数，即向CSP传递执行加密操作的参数。

它的作用：

1 指定特定的CSP。

2 管理密钥容器

3 指定签名密钥或交换密钥

重要成员：

ProviderType：指定提供程序的类型（按数值）。如下表

ProviderName：指定提供程序的类型（按名字）。如下表

提供程序类型	数值
PROV_RSA_FULL	1
PROV_RSA_SIG	2
PROV_DSS	3
PROV_FORTEZZA	4
PROV_MS_EXCHANGE	5
PROV_SSL	6
PROV_RSA_SCHANNEL	12
PROV_DSS_DH	13
PROV_EC_ECDSA_SIG	14
PROV_EC_ECNRA_SIG	15
PROV_EC_ECDSA_FULL	16
PROV_EC_ECNRA_FULL	17
PROV_DH_SCHANNEL	18
PROV_SPYRUS_LYNKS	20
PROV_RNG	21
PROV_INTEL_SEC	22
PROV_REPLACE_OWF	23
PROV_RSA_AES	24

以PROV_RSA_FULL类型为例：

用途	算法支持
KeyExchange	RSA
Signature	RSA
Encryption	RC2 RC4
Hashing	MD5 SHA

KeyNumber：指定密钥用作签名密钥还是交换密钥。

交换密钥是一个不对称密钥对，用于加密会话密钥，以便可以安全地存储会话密钥并与其他用户交换会话密钥。通过Exchange值(1)指定交换密钥。与CAPI中使用的AT_KEYEXCHANGE 值对应。

签名密钥是不对称密钥对，用于对数字签名的消息或文件进行身份验证。通过Signature值(2)指定签名密钥。与CAPI中使用的AT_SIGNATURE 值对应。默认情况下，KeyNumber字段指定交换密钥。

对这个属性对应的有一个同名的枚举KeyNumber：

Exchange	一个交换密钥对，用于加密会话密钥以使它们可以安全存储并与其他用户交换。
Signature	一个签名密钥对，用于对数字签名的消息或文件进行身份验证。

KeyContainerName：密钥容器名。通过它可以管理密钥容器：创建、获取、释放。

示例：密钥容器创建

public void Test_9_keycontainer()
{
    Encoding _encoding=Encoding.UTF8;
    string strPlaintext = "这是abc123!";
    byte[] bPlaintext = _encoding.GetBytes(strPlaintext);

    byte[] bEncrypt;
    byte[] bDecrypt;

    //创建容器
    CspParameters cspParams = new CspParameters();
    cspParams.KeyContainerName = "selfkeys";
    cspParams.ProviderType = 1;//PROV_RSA_FULL

    //创建密钥对，并添加到容器中
    RSACryptoServiceProvider provider = new RSACryptoServiceProvider(cspParams);

    //公钥加密
    RSACryptoServiceProvider _provider1 = new RSACryptoServiceProvider(cspParams);
    bEncrypt = _provider1.Encrypt(bPlaintext, true);
    Console.WriteLine(_encoding.GetString(bEncrypt));

    //私钥解密
    RSACryptoServiceProvider _provider2 = new RSACryptoServiceProvider(cspParams);
    bDecrypt = _provider2.Decrypt(bEncrypt, true);
    Console.WriteLine(_encoding.GetString(bDecrypt));
}

未完待续……

本文链接

javascript 表达式、括号、常用函数和jquery库怎么样实现的分析

2011-03-11T06:25:00Z

（一）javascript表达式

表达式是什么？表达式是对变更进行赋值、更改或计算等操作的语句。它是变量、常量、操作符的综合。根据操作符的不类型，可以分为字符操作表达式、赋值表达式、逻辑表达式、关系表达式、自增自减表达式、位表达式等。

例如：

x+y

5>0

A++

Z=1+1

另外还有一种逗号表达式：x+y,z++

（二）小括号

最常见的小括号的用法有好多种，并且常用。

（1）函数的输入参数部分

例如：function fun1()

（2）语句的辅助

例如：while()；if()；for()

（3）类对象的构造方法

Var now=new Date()

（4）强制表达式运算

这个作用其实也在用，但没有前边3种用得明晰。

它意思就是指：把其中的内容作为表达式强制运算后得到结果。

例如：

function test()
{
    var x = 0;
    var y = 1;
    alert(++x, ++y);
    alert((++x, ++y));
}

（5）函数调用

一般情况下调用函数为函数名+参数，例如：doTest(1)

还有一种方式就是把函数名也用小括号包围起来，例如：(doTest)(1)

这也是两个小括号的意义。

（三）中括号

中括号主要用于数组

（1）可以声明空数组或赋值，例如：

var list1 = [];

var list2 = [1, 2, 3];

（2）通过下标访数组元素

alert(list2[1]);

其次就是用于kv对的对象，例如：

对于customer对象，有name属性，那么取对象的name值为：

Customer[‘name’]

（四）大括号

常用的就是语句块标识符。例如函数体，循环体等。另一种就是定义js类。

例如：var customer = {};

可见：http://www.cnblogs.com/jams742003/archive/2011/03/04/1970506.html

（五）Eval

它的作用就是把字符串做为表达式进行运算，并返回值。

详细可见：http://www.cnblogs.com/jams742003/archive/2009/12/29/1634736.html

（六）Void

计算表达式，但不返回值。

例如：

var x = 1;

void (x++);

alert(x);

alert(typeof (void (x++)));

alert(x);

详细请见：http://www.cnblogs.com/jams742003/archive/2010/01/13/1646631.html

（七） Jquery库定义的原理分析

（1）如何通过一个变量进行访问所有成员

所有的成员，例如函数，变量等通过一个固定的变量访问，可以通过静态实现。那么就要创建一个类，且，类中的成员要定义为静态。所以，先试着创建一个jQuery类，它的成员为静态。如下：

function doClick()
{
jQuery.showMessage();
}

function jQuery()
{ }

jQuery.showMessage = function()
{
alert('ok');
}

（2）jQuery类可以通过另一种方式实现

定义js类有好几种方式，其中一种叫字面量的实现方式：

var jQuery = function() { };

jQuery.showMessage= function()
{
alert('ok');
}

（3）包装

为了避免命名冲突，现在把这个jQuery类包装起来。可以考虑再放到一个类中或者通过匿名函数进行包装（其实，本义是相同的）。在现在这种情况下，要通过后者方式进行，即以匿名函数进行包装。如下：

function()
{
    var jQuery = function() { };
    jQuery.showMessage = function()
    {
        alert('ok');
    }
}

（4）设置全局访问并添加$

如下：

function()
{
    var jQuery=window.jQuery=window.$= function() { };
    jQuery.showMessage = function()
    {
       alert(1);
    }
}

（5）让匿名函数运行

调用函数的方法可以通过函数名和输入参数。其中函数名也可以加小括号。那么：

(
        function()
        {
            var jQuery = window.jQuery = window.$ = function() { };
            jQuery.showMessage = function()
            {
                alert(1);
            }
        }
)();

（6）完成并调用

function doClick()
{
jQuery.showMessage();
$.showMessage();
}

本文链接