流云之心

翻译自

在开发中有很多小工具能够很高效的提高效率，感觉做开发的人员都会或多或少用到这些工具，这里就算抛砖引玉，看看大家是不是还有其他更好用的小工具 :)

1. 微软 SysinternalsSuite 系列工具

　　这套软件可以从technet直接下载，地址为http://technet.microsoft.com/en-us/sysinternals/bb842062.aspx。 开发人员常用的工具有以下几种

　 a. DbgView.exe

　　Debug Viewer 用来查看代码中trace信息。当然比不上windbg功能强大，但是在开发中基本上都是够用了。倒是性能调优的时候还是windbg比较有效

     b. procexp.exe

　　Process Explorer，可以看做任务管理器的升级版，可以找出进程打开了哪些文件、注册表项和其他对象以及已加载哪些 DLL 等信息

     c.procmon.exe

　　Process Monitor 实时监视文件系统、注册表、进程、线程和 DLL 活动

　　d. TCPView.exe

　　TCP Viewer, 查看TCP端口

另外提一个好玩的小东西，BlueScreen.exe,  是个屏幕保护程序，不仅精确模拟“蓝屏”，而且也模拟重新启动，包括进行磁盘检查等动作，可以用来吓唬老板同事 :)

2. IETester

针对国内用户存在大量使用IE的现状，可以通过IETester模拟各种IE版本查看效果

3. IE Developer 【IE8中已经包括进来】

    用来调整CSS, JS的好工具，可以直接在客户端更改后查看效果

4. Firebug [Firefox]

功能基本上同IE Developer, 只不过针对Firefox。可以利用它除错、编辑、甚至删改任何网站的 CSS、HTML、DOM、与 JavaScript 代码，

5. HttpWatch

跟踪客户端发出的Request和接受的Response的好工具，可以通过这个工具发现客户端究竟发出了那些请求，并可以看到Cookie，Header里面的相关信息

6. Fridler

功能基本上和HttpWatch一致，针对.net平台，好处是免费的

虽然现在博客园上关于设计模式的文章已经有很多，但还是写一篇来凑下热闹，也算是对自己多这几种模式得使用总结。

Factory Pattern 工厂模式和 Builder Patter 建造者模式都是通过定义接口来将类的定义和实现区分开来。下面一步一步来做说明

1. Simple Factory 简单工厂

 简单工厂只是将类简单抽象化，以Pizza为例，我们定义好Pizza的接口，实现继承Pizza的类PizzaA和PizzaB，然后简单工厂提供方法根据传进来的参数类型确定像调用者返回PizzaA或者PizzaB的实例

代码

    public interface Pizza
    {
        void DoPizza();
    }

    public class PizzaA : Pizza
    {
        public void DoPizza()
        {
            Console.WriteLine("pizza A");
        }
    }

    public class PizzaB : Pizza
    {
        public void DoPizza()
        {
            Console.WriteLine("pizza B");
        }
    }
   public static class SimplePizzaFacotry
    {
        public static Pizza Create(string type)
        {
            if (type == "PizzaA")
                return new PizzaA();
            else
                return new PizzaB();
        }
    }

    // Usage
    public class SimplePizzaFacotryOrder
    {
        public void OrderPizza()
        {
            Pizza pizza = SimplePizzaFacotry.Create("PizzaA");
            pizza.DoPizza();
        }
    }

2. Factory Method工厂方法 

工厂方式是在简单工厂模式基础上进一步抽象来符合OO设计的要求。这里将Factory抽象化为接口或抽象类，然后继承类负责具体实现。此时增加一个FactoryManage来负责返回那个工厂类实现的实例。代码示例如下 

代码

// Pizza, PizzaA, PizzaB继续使用简单工厂定义

    public abstract class PizzaFactory
    {
        public abstract Pizza Create();
    }

    public class PizzaAFactory : PizzaFactory
    {
        public override Pizza Create()
        {
            return new PizzaA();
            //throw new NotImplementedException();
        }
    }

    public class PizzaBFactory : PizzaFactory
    {
        public override Pizza Create()
        {
            return new PizzaB();
            //throw new NotImplementedException();
        }
    }

    public abstract class PizzaMethodManager
    {
        public static PizzaFactory Factory = new PizzaAFactory();
    }
    
    //usage 
    public class FactoryMethodPizzaOrder
    {
        public FactoryMethodPizzaOrder()
        {
            Pizza pizza = PizzaMethodManager.Factory.Create();
        }
    }

  3. Abstract Factory 抽象工厂

 抽象工厂和工厂方法基本上一样，区别在于此时抽象工厂可以来实现一系列相关类的实现。继续用Pizza举例，这里将Pizza分为Dough和Sauce即面团和酱，然后定义HutPizza和PapaPizza的面团Dougn, Sauce以及Pizza的实现。示例如下

代码

    public interface IDough
    {
       void DoDough();
    }

    public interface ISauce
    {
        void DoSauce();
    }

    public class PapaDough : IDough
    {
        public void DoDough()
        {
            Console.WriteLine("Papa Jone's Dough");
        }
    }

    public class PapaSource : ISauce
    {
        public void DoSauce()
        {
            Console.WriteLine("Papa Jone's Sauce");
        }
    }

    public class HutDough : IDough
    {
        public void DoDough()
        {
            Console.WriteLine("Pizza Hut's Dough");
        }
    }

    public class HutSource : ISauce
    {
        public void DoSauce()
        {
            Console.WriteLine("Pizza Hut's Sauce");
        }
    }

    public interface IPizzaFactory
    {
        IDough PrepareDough();
        ISauce AddSauce();
    }

    public class PapaPizzaFacotry : IPizzaFactory
    {
        public IDough PrepareDough()
        {
            return new PapaDough();
        }

        public ISauce AddSauce()
        {
            return new PapaSource();
        }
    }

    public class HutPizzaFacotry : IPizzaFactory
    {
        public IDough PrepareDough()
        {
            return new HutDough();
        }

        public ISauce AddSauce()
        {
            return new HutSource();
        }
    }

    public abstract class AbstractPizzaManager
    {
        public static IPizzaFactory Facotry = new PapaPizzaFacotry();
    }

    // Usage
    public class OrderPizzaAbstract
    {
        public void OrderPizza()
        {
            IDough dough = AbstractPizzaManager.Facotry.PrepareDough();
            ISauce sauce = AbstractPizzaManager.Facotry.AddSauce();
            dough.DoDough();
            sauce.DoSauce();
        }
    }

 4. Builder Pattern 建造者模式

 Builder和抽象工厂类似，也是建立一系列对象的实现。区别在于Builder建立的一对象有依赖关系而Factory的对象只是有关联。依旧以Pizza为例，pizza的做法是先做面团(饼底)，然后放Sauce(Cheese或者其他的东西)，然后放Topping(火腿，香肠之类的)。举例如下

代码

    class PizzaBD
    {
        public string Dough { get; set; }
        public string Sauce { get; set; }
        public string Topping { get; set; }
    }
     
    abstract class PizzaBuilder
    {
        public PizzaBD pizza { get; protected set; }
     
        public void CreatePizza()
        {
            pizza = new PizzaBD();
        }
     
        public abstract void BuildDough();
        public abstract void BuildSauce();
        public abstract void BuildTopping();
    }
     
    class HawaiianPizzaBuilder : PizzaBuilder
    {
        public override void  BuildDough()
        {
            pizza.Dough = "Cross";
        }
     
        public override void BuildSauce()
        {
            pizza.Sauce = "Mild";
        }
     
        public override void BuildTopping()
        {
            pizza.Topping = "Ham+Pineapple";
        }
    }
     
    class SpicyPizzaBuilder : PizzaBuilder
    {
        public override void BuildDough()
        {
            pizza.Dough = "Pan Baked";
        }
     
        public override void BuildSauce()
        {
            pizza.Sauce = "Hot";
        }
     
        public override void BuildTopping()
        {
            pizza.Topping = "Pepperoni+Salami";
        }
    }
     
    class Cook
    {
        public PizzaBuilder PizzaBuilder { get; set; }

        public PizzaBD Pizza { get { return PizzaBuilder.pizza; } }
     
        public void MakePizza()
        {
            PizzaBuilder.CreatePizza();
            PizzaBuilder.BuildDough();
            PizzaBuilder.BuildSauce();
            PizzaBuilder.BuildTopping();
        }
    }
     
    // usage 
    public class CallBuilder
    {
        public void OrderPizza()
        {
            Cook cook = new Cook();
            cook.PizzaBuilder = new SpicyPizzaBuilder();
            cook.MakePizza();
            cook.PizzaBuilder = new HawaiianPizzaBuilder();
            cook.MakePizza();
        }
    }

  5. Facade Pattern 外观模式

 提到了Builder模式，也就顺便提一下Facade模式。两者类似处在于都是建立一系列对象，区别在于Builder模式创建一系列有依赖关系的子类，而Facade模式则是建立一个将复杂的子类简化和集中化的通道。还是以Pizza为例，客户吃完付款，需要Waiter收取现金/卡，然后财务做账/transfer之后打印发票，返回。对客户来说后端多的一系列动作他并不关心，PizzaPayFacade提供给客户一个Pay方法，方法里面完成这一系列的动作[可能包括类的实现]。代码稍后提供。大家可以先参考First We try, then we trust的Facade说明的代码示例 http://www.cnblogs.com/zhenyulu/articles/55992.html

最近在空余时间随手写的一个小程序，欢迎大家试用，有什么意见建议请留言。

版本更新：

增加多语言支持

增加对全屏事件检测，在全屏玩游戏，看电影的时候不在计时

没有做安装程序，下载Bin包直接解压即可用。

程序和源代码下载

http://eyeguardian.sourceforge.net/