如果每天工作太忙，应酬太多，不能够从日常生活中得到很好的排毒效果，那就挤出三天时间，试试集中排毒的功效吧!

第一天

早餐：鲜奶麦片，或低脂鲜奶一杯，加两片苏打饼干。

午餐：白饭半碗，火龙银耳雪梨，柳橙一个。

晚餐：白饭半碗，闷烧菜色(盖上锅盖，以小火将菜闷至熟)半碟，鸡肉少许，水果适量。

第二天

早餐：蔬果汁一杯，加一份水果。

午餐：加柠檬汁的生菜沙拉一碗，猪手煲黄豆。

晚餐：闷烧菜色(盖上锅盖，以小火将菜闷至熟)半碟，香蕉一根，西红柿青菜汤一碗。

第三天

早餐：白粥半碗。

午餐：白粥一碗，寺院佛中宝。

晚餐：瘦肉粥一碗。

每天应该喝水8-10杯，以帮助清洁肠胃及排毒。

水煮食材口味清爽，减少油份。闷烧青菜，则是有助肝肾休息，帮助排毒去水。

1、达到组建开发团队的基本前提。

a：开始小规模或者大规模建立开发团队的前提是项目雏形及资金到位。

b：任何投资人、创业者都有一个潜意识，用最少的成本来作最多的事情。

   以上两条是开始组建正式的开发团队的前提，否则的话，建议创业者或者投资人还是多做做项目雏形(商业目的、策划流程、营销流程)、资金等方面的事情。当然上面这些东西不一定是尽善尽美的，也没有这个必要，但至少工作任务及资金够未来3个月的使用。

2、团队的规模的确立

   在有了建立正式的开发团队的前提后，现在要思考的则是团队的规模。在项目管理上，我习惯于把这个称为确定项目范围。毛主席曾经说过，“人多力量大”。而对于这个团队的老板而言就不能这么想了，疯狂的扩张之后必定是疯狂的裁员，即便是跨国集团也会走这条路。而对于一个成立初期的项目而言，这意味着失败。从个人的经验来说，初始的开发团队的规模是在 6人-10人之间。6人是各个职位填充式的建立，而10人则是增加了人员风险的处理及工作效率的保障。

   6人职位是：项目经理、项目助理(兼任数据库工程师)、架构师(软硬件架构)、UI设计师、测试工程师、部署工程师，以上职位必须全部具有编码能力，并能快速的编码。

   10人职位是：项目经理、项目助理、架构师、数据库工程师、UI设计师2名、软件工程师2名、测试工程师、部署工程师。

   对于大型或者巨型的企业来说，他们可以承受裁员的压力(对于上市公司来说，裁员会刺激股票)，而对于创业公司的开发团队来说，要尽量保持其至少1年的稳定性。

3、寻找吸引人才的理由

   有了项目雏形及启动资金，那么一定要思考下，用什么来吸引优秀的开发人才。“良琴择木而栖”，再有激情的创业者，也需要一个创业的理由；再有激情的开发人员也需要一个开发理由。千万不要主观的认为开发人员就是代码机器，给你工资、福利老实的干活就可以了。也就是说对于开发团队的大大小小的职位都要给与其存在的理由。

4、给与人员发展的空间

   问一个简单的问题，在你面试的时候，面试官会否问你未来的职业规划？如果问了你，你是否会表达你的职业规划？这一点被大多数创业公司忽略了，以致于现在流行这样一句话"职业进步的阶梯就是跳槽"。对于创业公司来说，要避免“天花板效应的过早到来”，人都有惰性，都需要刺激。虽然最终的结果比例还是“铁打的营盘、流水的兵”，但这一天越晚爆发，对于项目来说就越有利。也就是说，对于优秀的人才要给与发展的空间，很多时候，这些人都是未来团队扩大后的项目经理。比如UI有UI项目经理、测试项目经理、部署项目经理、首席架构师、资深DBA等等。对于创业公司来说，不要着急把顶级组织结构的空缺填满，留有一定的空间反而会更好，其实也是更省钱的方式，开个玩笑。

5、挑选一个性格健全的项目经理

   项目经理是可以被替代的，替代者就是团队中的任何一个下属(一般是项目助理接替)。但性格健全的项目经理在被替代之后，给团队留下的是正常的可改造性；而性格有问题的项目经理在替代之后，新的项目经理会发现团队陋习太多，疾病难改，那就麻烦了。在这里我们要明白的是项目经理存在的价值取向，他的发言权是建立在他对于行业的专家能力及个人的人格魅力上的。专家能力可以培养，但性格是人生的烙印。性格决定了太多东西，尽量减少这方面带来的负影响。项目经理是最低级别的职业经理人，对于职业经理人的要求我在这里就不班门弄斧了。

6、建立公平的薪酬体系

   薪资、福利，是公司制度性的契约。我们必须要承认、不同的职位薪资是有落差的，这是正常的。所以要避免地是工资无落差或者落差过大，这对于开发团队的稳定是必然的。大家在一起工作久了，工资很难成为秘密。如果创业者觉得有必要避免这方面的麻烦，那么最好明确一条规矩，禁止谈论工资。每一级别的薪资落差幅度应该在20%左右最为适宜，比如项目经理月薪资10K RMB，那么项目助理、架构师的月薪资应该在8K元左右浮动。如果项目经理的月薪资在8K 美金，那么项目助理、架构师的月薪资在6.4K 美金左右。详细的数据要根据具体的公司及案例来制定。同工同酬、至少在同一工资等级是最好的薪资体系。比如规定下，程序员工资等级在2K-5K的等级浮 动，对于刚毕业的、工作一年的、两年的在参考个人能力的前提下评定其薪资等级。

7、建立有效的激励制度

   不乱讲空话，言出必行。很多时候，我们在做一件事情的时候，需要额外的成本支出。这就是奖金、期权、股份、旅游活动等组成的激励制度。这是一种非制度性的契约，大多数是公司的隐形文化。但它的存在本身就是增加团队凝结力及挖掘个人工作激情的工作方法。可以没有，最多员工会说老板很扣，但切忌答应了而不履行的。在这里有一个“区别对待”的概念，工资可以就其工作能力来评定，但奖金呢？发奖金、期权、股份一定要找到表现最优秀的哪20%-30%的人，这是杰克.韦尔奇的经典的20%、70%、10%的经验写照。对于表现非常优秀的20%员工，要给与特别的奖励；对于中规中矩的70%的人来说，前面的一部份虽然没有被评为20%，但也非常优秀，所以要给与奖励；对于表现不合格的10%，要给与相应的处罚。难点就是你如何评估奖励的人和处罚的人。

问题解析：

1、团队中的每个人都是精英，那么何必采用区别对待和等级薪资呢？

   回答：是的，建立精英团队是我们的终极目标，但这说的是建立精英文化，而不是精英组合的团队。相反，在这个世界上，你必须要认识到有人是领导者，有人就是被领导者。包括家庭也是，要么你领导，要么你的另一半领导。企业需要的是最合适的人，而不是最优秀的人。补充下，团队中的人最好以组合的方式进行搭配，要么以专长组合，要们就以能力组合。如果把中国最优秀的6个数据库设计人员放到一个团队，想象下会是个什么样的情况。如果是你，我想你会把最优秀的6个数据库设计人员放到6个团队中吧！

2、我们拉到了很多投资，扩充队伍不是很正常么？

   回答：风险投资的钱现在看来似乎好拿一些，但想下吧，6个月后，12个月后，如果没有下一批资金的到位，你的企业还能运作下去么？这里稍微提下baidu 的发家史，6个月的钱考虑12个月用？未雨绸缪，互联网的下一次经济危机什么时候到来不得而知，但对于你的企业及员工负责，还是省省吧！至少保证尽量少裁员、准时发工资的要求。如今的年代，很难再有史玉柱倒下，团队依然跟随的故事了。

3、各个职位确定了，大家不就能够各司其职了么？

   回答：公司稳定了，再确定职位反而比过早的形成组织结构好。为什么这么说，企业的发展，空降兵的加盟是必然的，每一轮的加盟都需要调整企业的组织结构本身就是对于企业的伤害。在关注很多大的公司的组织结构后得出的一点点见解，2年以上更换一个职位会比较稳妥。对于创业型的公司来说，CEO，CMO， CTO，CFO等等不必着急占坑，现在明显感觉这些职位满天飞。以前有句玩笑话“楼上掉了个冰箱，砸死5个人，4个是总经理，一个是副总经理”，现在是否“楼上掉个冰箱，砸死5个人，CEO，CMO，CTO，CFO，还有一个是人力资源总监”。职位的贬值越发的快了，但其实却不如“我管运营的、我管技术的、我管人事的”来得实在。未上市前，也就是说在1年的上市准备期和至少8个月的沉默期之前来说，这个O，那个O的，还是少些的好。实际的第三层到位既可。

工厂类：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个具体的类实现。

抽象产品角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或她们共同拥有的接口。一般由接口或抽象类实现。

具体产品角色：工厂方法模式所创建的任何对象都是这个角色的实例，由具体类实现。

简单工厂模式优缺点：
    模式的核心是工厂类，这个类负责产品的创建，而客户端可以免去产品创建的责任，这实现了责任的分割。但由于工厂类集中了所有产品的创建逻辑，如果不能正常工作的话会对系统造成很大的影响。如果增加新产品必须修改工厂角色的源码。

例子1：

using System;

namespace SimpleFactoryPattern
{
    //定义Food接口
    public interface Food
    {
        //烹饪
        void Cook();
           
        //卖出
        void Sell();
    }
        
    //Noodle
    public class Noodle:Food
    {
        private int price;

        public Noodle()
        {
            Console.WriteLine("\nThe Noodle is made..");
        }

        //面条Noodle的Cook方法接口实现
        public void Cook()
        {
            Console.WriteLine("\nNoodle is cooking...");
        }

        //面条Noodle的Sell方法接口实现
        public void Sell()
        {
            Console.WriteLine("\nNoodle has been sold...");
        }

        public int Price
        {
            get { return this.price; }
            set { price=value; }
        }
    }

    //Rice
    public class Rice:Food
    {
        private int price;

        public Rice()
        {
            Console.WriteLine("\nThe Rice is made ..");
        }

        public void Cook()
        {
            Console.WriteLine("\nRice is cooking...");
        }

        public void Sell()
        {
            Console.WriteLine("\nRice has been sold...");
        }

        public int Price
        {
            get { return this.price; }
            set { price=value; }
        }
    }

    //Bread
    public class Bread:Food
    {
        private int price;

        public Bread()
        {
            Console.WriteLine("\nThe Bread is made....");
        }
        public void Cook()
        {
            Console.WriteLine("\nBread is cooking...");
        }

        public void Sell()
        {
            Console.WriteLine("\nBread has been sold...");
        }

        public int Price
        {
            get { return this.price; }
            set { price=value; } 
        }
    }

    //定义大厨，他包办这个快餐店里的所有Food,包括面条，面包和米饭
    class Chef
    {
        public static Food MakeFood(string foodName)
        {
            try
            {
                switch(foodName)
                {
                    case "noodle": return new Noodle();
                    case "rice":return new Rice();
                    case "bread":return new Bread();
                    default:throw new BadFoodException("Bad food request!");
                }
            }
                 
            catch(BadFoodException e)
            {
                throw e;
            }
        }
    }

    //异常类，该餐馆没有的食品
    class BadFoodException: System.Exception
    {
        public BadFoodException(string strMsg)
        {
            Console.WriteLine(strMsg);
        }
    }

    public class Test
    {
        [STAThread]
        public static void Main(string[] args)
        {
            Food food=Chef.MakeFood("bread");
            food.Cook();
            food.Sell();
     
            Console.ReadLine();
        }
    }
}

工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

例子1：

using System;

namespace 工厂方法模式

{

    public interface 运动员

    {

        public void 跑();

        public void 跳();

    }

    public class 足球运动员 : 运动员

    {

        public void 跑()

        {

            //跑啊跑

        }

        public void 跳()

        {

            //跳啊跳

        }

    }

    public class 篮球运动员 : 运动员

    {

        public void 跑()

        {

            //Do nothing

        }

        public void 跳()

        {

            //Do nothing

        }

    }

    public interface 体育协会

    {

        public 运动员 注册();

    }

    public class 足球协会 : 体育协会

    {

        public 运动员 注册()

        {

            return new 足球运动员();

        }

    }

    public class 篮球协会 : 体育协会

    {

        public 运动员 注册()

        {

            return new 篮球运动员();

        }

    }

    public class 足球俱乐部

    {

        private 运动员 守门员 = null;

        private 运动员 后卫 = null;

        private 运动员 前锋 = null;

        public void Test()

        {

            体育协会 中国足协 = new 足球协会();

            this.守门员 = 中国足协.注册();

            this.后卫 = 中国足协.注册();

            this.前锋 = 中国足协.注册();

        }

    }

    public class 篮球俱乐部

    {

        private 运动员 运动员1 = null;

        private 运动员 运动员2 = null;

        private 运动员 运动员3 = null;

        public void Test()

        {

            体育协会 中国篮协 = new 篮球协会();

            this.运动员1 = 中国篮协.注册();

            this.运动员2 = 中国篮协.注册();

            this.运动员3 = 中国篮协.注册();

        }

    }

}

话说十年前，有一个暴发户，他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪，还雇了司机为他开车。不过，暴发户坐车时总是怪怪的：上Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上Audi说“开奥迪车！”。你一定说：这人有病！直接说开车不就行了？！

例子1：

using System;

namespace 抽象工厂模式

{

    //面条的公共操作

    public interface Noodle

    { }

    //北方面条

    public class NorthNoodle : Noodle

    {

        public NorthNoodle()

        {

            Console.Write("一碗地道的北方面条做好了");

        }

    }

    //南方面条

    public class SouthNoodle : Noodle

    {

        public SouthNoodle()

        {

            Console.Write("一碗地道的南方面条做好了");

        }

    }

    //米饭的公共操作

    public interface Rice

    { }

   //北方米饭

    public class NorthRice : Rice

    {

        public NorthRice()

        {

            Console.Write("一碗地道的北方米饭做好了");

        }

    }

    //南方米饭

    public class SouthRice : Rice

    {

        public SouthRice()

        {

            Console.Write("一碗地道的南方米饭做好了");

        }

    }

    //面包的公共操作

    public interface Bread

    { }

    //北方面包

    public class NorthBread : Bread

    {

        public NorthBread()

        {

            Console.Write("一块地道的北方面包做好了");

        }

    }

    //南方面包

    public class SouthBread : Bread

    {

        public SouthBread()

        {

            Console.Write("一块地道的南方面包做好了");

        }

    }

    //厨师的公共操作

    public interface Chef

    {

        //制作面条

        Noodle MakeNoodle();

        //制作米饭

        Rice MakeRice();

        //制作面包

        Bread MakeBread();

    }

    //北方厨师

    public class NorthChef : Chef

    {

        //制作北方面条

        public Noodle MakeNoodle()

        {

            return new NorthNoodle();

        }

        //制作北方米饭

        public Rice MakeRice()

        {

            return new NorthRice();

        }

        //制作北方面包

        public Bread MakeBread()

        {

            return new NorthBread();

        }

    }

    //南方厨师

    public class SorthChef : Chef

    {

        //制作南方面条

        public Noodle MakeNoodle()

        {

            return new SouthNoodle();

        }

        //制作南方米饭

        public Rice MakeRice()

        {

            return new SouthRice();

        }

        //制作南方面包

        public Bread MakeBread()

        {

            return new SouthBread();

        }

    }

    public class Test

    {

        public void Test()

        {

            //北方厨师

            Chef objNorthChef = new NorthChef();

            objNorthChef.MakeNoodle();

            objNorthChef.MakeRice();

            objNorthChef.MakeBread();

            //南方厨师

            Chef objSouthChef = new SorthChef();

            objSouthChef.MakeNoodle();

            objSouthChef.MakeRice();

            objSouthChef.MakeBread();

        }

    }

}

using System;

namespace 单件模式

{

    //单线程Singleton模式

    public class Singleton

    {

        private static Singleton objSingleton = null;

        private Singleton()

        { }

        public Singleton GetInstance()

        {

            if (objSingleton == null)

            {

                objSingleton = new Singleton();

            }

            return objSingleton;

        }

    }

    //多线程Singleton模式

    public class Singleton

    {

        private static volatile Singleton objSingleton = null;

        private static object objLockHelper = new object();

        private Singleton()

        { }

        public Singleton GetInstance()

        {

            if (objSingleton == null)

            {

                lock (objLockHelper)

                {

                    if (objSingleton == null)

                    {

                        objSingleton = new Singleton();

                    }

                }

            }

            return objSingleton;

        }

    }

}

网络编程所使用的名称空间

System.Net

System.Net.Sockets

概念解释：

同步(synchronous)　　

    发送方发送数据包以后，不等接受方响应，就接着发送下一个数据包。

异步(asynchronous)

    发送方发送一个数据包以后，一直等到接受方响应后，才接着发送下一个数据包。

阻塞(Block)

    阻塞套接字是指执行此套接字的网络调用时，直到调用成功才返回，否则此套节字就一直阻塞在网络调用上。

    比如调用StreamReader类的ReadLine()方法读取网络缓冲区中的数据，如果调用的时候没有数据到达，那么此

    ReadLine()方法将一直挂在调用上，直到读到一些数据，此函数调用才返回。

非阻塞(Unblock)

    非阻塞套接字是指在执行此套接字的网络调用时，不管是否执行成功，都立即返回。

    调用StreamReader类的ReadLine()方法读取网络缓冲区中数据，不管是否读到数据都立即返回，而不会一直挂

    在此函数调用上。

在Windows网络通信软件开发中，最为常用的方法就是异步非阻塞套接字。平常所说的C/S（客户端/服务器）结构的软件采用的方式就是异步非阻塞模式的。

(异步阻塞)

    1、首先要要在给定的端口上面创建一个“TcpListener”对象侦听网络上面的请求，当接收到连结请求后通过

       调用“TcpListener”对象的"AcceptSocket"方法产生一个用于处理接入连接请求的Socket的实例。

       //创建一个TcpListener对象，此对象主要是对给定端口进行侦听

       TcpListener objTcpListener = new TcpListener(1234);

       //开始侦听

       objTcpListener.Start();

       //返回可以用以处理连接的Socket实例

       Socket socketForClient = tcpListener.AcceptSocket();  

    2、接受和发送客户端数据

       在请求通过以后，Socket实例构造一个“NetworkStream”对象，“NetworkStream”对象为网络访问提供

       了基础数据流。

       通过“System.IO”中的“StreamReader”和“StreamWriter”来实现对“NetworkStream”对象的访问。

       “StreamReader”类中的ReadLine()方法就是从“NetworkStream”对象中读取一行字符

       “StreamWriter”类中的WriteLine()方法就是对"NetworkStream"对象中写入一行字符串

       try 

       { 

           //如果返回值是"true"，则产生的套节字已经接受来自远方的连接请求，已经和客户端成功连接

           if (socketForClient.Connected) 

           {

               //创建NetworkStream对象通过网络套节字来接受和发送数据 

               NetworkStream objNetworkStream = new NetworkStream(socketForClient);

               StreamReader objStreamReader = new StreamReader(objNetworkStream);

               StreamWriter objStreamWriter = new StreamWriter(objNetworkStream);

               while (true)

               { 

                   //从当前数据流中读取一行字符，返回值是字符串 

                   string msg = streamReader.ReadLine(); 

                   //往当前的数据流中写入一行字符串

                   streamWriter.WriteLine("String");

                   //刷新当前数据流中的数据 

                   objStreamWriter.Flush ( );

               } 

           } 

       }

       catch(Exception ey)

       { 

           MessageBox.Show(ey.ToString()); 

       }

    3、关闭所有流，停止侦听网络，关闭套节字

       //关闭线程和流

       objStreamReader.Close();

       objStreamWriter.Close();

       objNetworkStream.Close(); 

       socketForClient.Shutdown(SocketShutdown.Both);

       socketForClient.Close();

       objTcpListener.Stop();

       objThread.Abort();

using System;

using System.Collections;

namespace 生成器模式

{

    //产品

    public class Product

    {

        ArrayList parts = new ArrayList();

        public void Add(string part)

        {

            parts.Add(part);

        }

        public void Show()

        {

            foreach (string part in parts)

            {

                Console.WriteLine(part);

            }

        }

    }

    //制造者

    public abstract class Builder

    {

        //制造PartA

        public abstract void BuildPartA();

        //制造PartB

        public abstract void BuildPartB();

        //得到产品

        public abstract Product GetResult();

    }

    //具体制造者1

    public class ConcreteBuilder1 : Builder

    {

        private Product objProduct = null;

        //制造PartA

        public override void BuildPartA()

        {

            this.objProduct = new Product();

            this.objProduct.Add("PartA");

        }

        //制造PartB

        public override void BuildPartB()

        {

            this.objProduct.Add("PartB");

        }

        //得到产品

        public override Product GetResult()

        {

            return this.objProduct;

        }

    }

    //具体制造者2

    public class ConcreteBuilder2 : Builder

    {

        private Product objProduct = null;

        //制造PartA

        public override void BuildPartA()

        {

            this.objProduct = new Product();

            this.objProduct.Add("PartX");

        }

        //制造PartB

        public override void BuildPartB()

        {

            this.objProduct.Add("PartY");

        }

        //得到产品

        public override Product GetResult()

        {

            return this.objProduct;

        }

    }

    //指挥者

    public class Director

    {

        //指挥制造者制造产品

        public void Construct(Builder objBuilder)

        {

            objBuilder.BuildPartA();

            objBuilder.BuildPartB();

        }

    }

    public class Test

    {

        public void Test()

        {

            //指挥者

            Director objDirector = new Director();

            //制造者1

            Builder objBuilder1 = new ConcreteBuilder1();

            //制造者2

            Builder objBuilder2 = new ConcreteBuilder2();

            //指挥者指挥制造者1制造产品1

            objDirector.Construct(objBuilder1);

            Product objProduct1 = objBuilder1.GetResult();

            objProduct1.Show();

            //指挥者指挥制造者2制造产品2

            objDirector.Construct(objBuilder2);

            Product objProduct2 = objBuilder2.GetResult();

            objProduct2.Show();

        }       

    }

}

1、为什么要用原型？用原型的好处

    比如我们有一个工具栏按钮，新建按钮，它是ToolbarButton的实例，它有长度、宽度属性等，而且属性都赋了值。现在我们要再添加一个保存按钮，它也是ToolbarButton的实例，它也有长度、宽度属性等，不过它还没赋值，它的值和新建按钮的值一样。如果我们不用原型设计模式的话，可能重新赋一遍值。如果我们用原型设计模式的话，我们可以把新建按钮作为保存按钮的原型。那样的话就不需要再给保存按钮赋值，它的默认的长度、宽度就和新建按钮一样了。

2、  在C#中怎样用原型？

    因为类的实例是引用类型，要想用原有的类中的实例的数据的话，只能用clone方法。Clone方法分为深clone和浅clone。在C#中提供了浅clone的方法，即为MemberwiseClone()。

例子1：

using System;

namespace 原型模式

{

    public class ToolbarButton : ICloneable     //实现ICloneable接口

    {

        private int width;

        private int height;

        public ToolbarButton()

        { }

        public int Width

        {

            get

            {

                return this.width;

            }

            set

            {

                this.width = value;

            }

        }

        public int Height

        {

            get

            {

                return this.height;

            }

            set

            {

                this.height = value;

            }

        }

        public Object Clone()

        {

            return this.MemberwiseClone();     //返回浅副本

        }

    }

    public class Test

    {

        public void Test()

        {

            ToolbarButton mtb_NewButton = new ToolbarButton();

            mtb_NewButton.Width = 60;

            mtb_NewButton.Height = 30;

            ToolbarButton mtb_SaveButton = new ToolbarButton();

            mtb_SaveButton = (ToolbarButton)mtb_NewButton.Clone();

            //这时mtb_SaveButton就有Width和Height值了

        }

    }

}

 适配器模式负责在用户需求接口与不同的实现类之间的转换。如果客户需要某个类的服务而这个服务是这个类用不同的的接口提供的，那么就可以用适配器模式为客户提供一个期望的接口。分为两种情况：

    1、类适配器，模式原型的实现方法是，定义或获取一个需求的接口，包含一个或多个需求的方法，定义一个适配器类，继承于接口和实现接口需求的外部类，将客户的需求传递给实现需求的外部类，即达到了本模式的要求。

using System;

namespace 适配器模式

{

    interface I目标

    {

        void Request();

    }

    class 源

    {

        public void 源Request()

        {

            //Do

        }

    }

    class 适配器 : 源, I目标

    {

        public void Request()

        {

            this.源Request();

        }

    }

    class Test

    {

        public void Test()

        {

            I目标 objI目标 = new 适配器();

            objI目标.Request();

        }

    }

}

    2、对象适配器，如果没有定义一个接口，我们也可以使用适配器模式，这就是用对象适配器模式，定义一个类，定义一个可重写的虚方法，实现一个继承于需求类的适配器类，在这个类内部实例化一个能满足需求类的外部类，重写需求方法，将外部类方法传递给需求方法。

using System;

namespace 适配器模式

{

    class 目标

    {

        virtual public void Request()

        { }

    }

    class 源

    {

        public void 源Request()

        {

            //Do

        }

    }

    class 适配器 : 目标

    {

        private 源 obj源 = new 源();

        public override void Request()

        {

            this.obj源.源Request();

        }

    }

    class Test

    {

        public void Test()

        {

            目标 obj目标 = new 适配器();

            obj目标.Request();

        }

    }

}

using System;

namespace 桥接模式

{

    public abstract class Log

    {

        public abstract void Write(string log);

    }

    public class DataBaseLog : Log

    {

        public override void Write(string log)

        {

            //Log...DataBase

        }

    }

    public class TextFileLog : Log

    {

        public override void Write(string log)

        {

            //Log...TextFile

        }

    }

    public class NDataBaseLog : DataBaseLog

    {

        public override void Write(string log)

        {

            //.Net平台 Log...DataBase   

        }

    }

    public class JDataBaseLog : DataBaseLog

    {

        public override void Write(string log)

        {

            //Java平台 Log...DataBase

        }

    }

    public class NTextFileLog : Log

    {

        public override void Write(string log)

        {

            //.Net平台 Log...TextFile

        }

    }

    public class JTextFileLog : Log

    {

        public override void Write(string log)

        {

            //Java平台 Log...TextFile

        }

    }

    public abstract class ImpLog

    {

        public abstract void Execute(string msg);

    }

    public class NImpLog : ImpLog

    {

        public override void Execute(string msg)

        {

            //.Net平台

        }

    }

    public class JImpLog : ImpLog

    {

        public override void Execute(string msg)

        {

            //Java平台

        }

    }

    public abstract class Log

    {

        protected ImpLog implementor;

        public ImpLog Implementor

        {

            set

            {

                this.implementor = value;

            }

        }

        public virtual void Write(string log)

        {

            this.implementor.Execute(log);

        }

    }

    public class DataBaseLog : Log

    {

        public override void Write(string log)

        {

            this.implementor.Execute(log);

        }

    }

    public class TextFileLog : Log

    {

        public override void Write(string log)

        {

            this.implementor.Execute(log);

        }

    }

    public class Test

    {

        public void Test()

        {

            //.Net平台下的DataBase Log

            Log dbLog = new DataBaseLog();

            dbLog.Implementor = new NImpLog();

            dbLog.Write("");

            //Java平台下的Text File Log

            Log txtLog = new TextFileLog();

            txtLog.Implementor = new JImpLog();

            txtLog.Write("");

        }

    }

}

using System;

using System.Collections;

namespace 组合模式

{

    //文件夹的例子，文件夹包含子文件夹和文件

    //文件和文件夹的父接口

    public interface FolderBase

    {

        void AddChild(FolderBase objFolderBase);    //添加子文件夹

        void Display();                             //显示文件或文件夹

    }

    //文件

    public class File : FolderBase

    {

        private int value = 0;

        public File(int value)

        {

            this.value = value;

        }

        public void AddChild(FolderBase objFolderBase)

        {

            //没有子文件，所以为空

        }

        public void Display()

        {

            Console.Write(value);

        }

    }

    //文件夹

    public class Folder : FolderBase

    {

        private int value = 0;

        private ArrayList objChildrenList = new ArrayList();

        public Folder(int value)

        {

            this.value = value;

        }

        //添加子文件或子文件夹

        public void AddChild(FolderBase objFolderBase)

        {

            this.objChildrenList.Add(objFolderBase);

        }

        public void Display()

        {

            //显示所有的子文件或子文件夹

            foreach (FolderBase objChild in this.objChildrenList)

            {

                objChild.Display();

            }

        }

    }

    public class Test

    {

        public void TestMethod()

        {

            Folder objRootFolder = new Folder(0);           //根文件夹

            File objFile1 = new File(1);                   //文件1

            Folder objFolder1 = new Folder(10);            //文件夹1

            File objFile2 = new File(2);                   //文件2

            File objFile3 = new File(3);                   //文件3

            objFolder1.AddChild(objFile2);                 //添加文件2到文件夹1中

            objFolder1.AddChild(objFile3);                 //添加文件3到文件夹1中

            objRootFolder.AddChild(objFile1);              //添加文件1到根文件夹中

            objRootFolder.AddChild(objFolder1);            //添加文件夹1到根文件家中

            objRootFolder.Display();                       //显示根文件夹下所有的文件和文件夹

        }

    }

}

using System;

namespace 装饰模式

{

    //抽象构件

    abstract class Component

    {

        public abstract void Operation();

    }

    //具体构件

    class ConcreteComponent : Component

    {

        public override void Operation()

        {}

    }

    //抽象装饰

    abstract class Decorator : Component

    {

        protected Component objComponent = null;

        public void SetComponent(Component objComponent)

        {

            this.objComponent = objComponent;

        }

        public override void Operation()

        {

            if (this.objComponent != null)

            {

                this.objComponent.Operation();

            }

        }

    }

    //具体装饰A

    class ConcreteDecoratorA : Decorator

    {

        private string addedState = null;

        public override void Operation()

        {

            base.Operation();

            this.addedState = "New State";

        }

    }

    //具体装饰B

    class ConcreteDecoratorB : Decorator

    {

        public override void Operation()

        {

            base.Operation();

            this.AddedBehavior();

        }

        private void AddedBehavior

        { }

    }

    public class Test

    {

        public void TestMethod()

        {

            ConcreteComponent objCC = new ConcreteComponent();

            ConcreteDecoratorA objCDA = new ConcreteDecoratorA();

            ConcreteDecoratorB objCDB = new ConcreteDecoratorB();

            objCDA.SetComponent(objCC);

            objCDB.SetComponent(objCDA);

            objCDB.Operation();

        }

    }

}

SQL Server 2000 的全文检索

1、创建全文检索

   创建全文索引的具体步骤(括号内为每步所调用的存储过程名称)：

       (1)启动数据库的全文检索功能(sp_fulltext_database)

       (2)建立全文检索目录(sp_fulltext_catalog)

       (3)在全文检索目录中注册需要进行全文检索的表(sp_fulltext_table)

       (4)指出表中需要进行全文检索的列(sp_fulltext_column)

       (5)为表创建全文索引(sp_fulltext_table)

       (6)填充全文索引(sp_fulltext_catalog)

   1、验证全文检索组件是否已经安装

      select fulltextserviceproperty('IsFullTextInstalled')

      返回1表示已经安装，返回0表示没有安装，返回null表示输入无效或者发生错误

   2、修改全文检索的语言为中文

      use master

      go

      exec sp_configure 'default full-text language', '2052'

      go

      reconfigure with override

      go

   3、打开(关闭)数据库全文索引的支持

      use 'DatabaseName'

      exec sp_fulltext_database 'enable'('disable')

   4、建立(重建)(删除)全文检索目录

      use 'DatabaseName'

      exec sp_fulltext_catalog '全文检索目录名', 'create'('rebuild')('drop')

   5、为表建立全文检索数据元

      use 'DatabaseName'

      exec sp_fulltext_table 'TableName', 'create', '全文检索目录名', 'Table主键约束名或唯一约束名'

   6、设置需要检索的列(可以添加多个)

      exec sp_fulltext_column 'TableName', 'ColumnName', 'add'

   7、激活(关闭)全文检索

      exec sp_fulltext_table 'TableName', 'activate'('deactivate')

   8、启动(停止)全文检索目录的填充

      exec sp_fulltext_catalog '全文检索目录名', 'start_full'('stop')

      检查全文检索目录填充情况

      select fulltextcatalogproperty('全文检索目录名', 'Populatestatus')

      返回1表示正在进行，返回0表示已经完成

   9、延时，填充全文检索后，需要有一定的延迟时间才会生效，所以要延时

      waitfor delay '00:00:10'

      go

2、使用全文检索：

   1、检索表中既包含b又包含c的所有行(注：列名不带引号)

      select * from TableName where contains(列名(, 列名), 'b*' and 'c*')

   2、检索表中包含chai，chang，tofu之一的所有列

      select * from TableName where freetext(列名(, 列名), 'chai chang tofu')

using System;

namespace 外观模式

{

    public class DrawLine

    {

        private int count = 0;

        public DrawLine(int count)

        {

            this.count = count;

        }

        //画下划线

        public void DrawUnderLine()

        {

            for (int i = 0; i < this.count; i++)

            {

                Console.WriteLine("_");

            }

        }

        //画中划线

        public void DrawMiddleLine()

        {

            for (int i = 0; i < this.count; i++)

            {

                Console.WriteLine("-");

            }

        }

    }

    public class ShowData

    {

        private string defaultValue = null;

        public ShowData(string defaultValue)

        {

            this.defaultValue = defaultValue;

        }

        //显示简单的数据

        public void ShowShortDate(string outsideValue)

        {

            Console.WriteLine(this.defaultValue + ":" + outsideValue);

        }

        //显示详细的数据

        public void ShowParticularData(int time, string outsideValue)

        {

            for (int i = 0; i < time; i++)

            {

                Console.WriteLine(outsideValue);

                Console.WriteLine("|");

            }

        }

    }

    //使用外观模式，向外提供各个子系统的功能

    public class Facade

    {

        private int times = 0;

        private string defaultValue = null;

        private DrawLine objDrawLine = null;

        private ShowData objShowData = null;

        public Facade(int times, string defaultValue)

        {

            this.times = times;

            this.defaultValue = defaultValue;

            this.objDrawLine = new DrawLine(this.times);

            this.objShowData = new ShowData(this.defaultValue);

        }

        //画下划线，显示详细的数据

        public void DrawPicture()

        {

            this.objDrawLine.DrawUnderLine();

            this.objShowData.ShowParticularData(this.times, this.defaultValue);

        }

        //画中划线，显示简单的数据

        public void DrawImage()

        {

            this.objDrawLine.DrawMiddleLine();

            this.objShowData.ShowShortDate(this.defaultValue);

        }

    }

    public class Client

    {

        private const int times = 10;

        private const string defaultValue = "默认值";

        public void Test()

        {

            //不使用外观模式，常见的用法

            DrawLine objDrawLine = new DrawLine(times);

            ShowData objShowData = new ShowData(defaultValue);

            objDrawLine.DrawUnderLine();

            objDrawLine.DrawMiddleLine();

            objShowData.ShowParticularData(times, defaultValue);

            objShowData.ShowShortDate(defaultValue);

            //使用外观模式

            Facade objFacade = new Facade(times, defaultValue);

            objFacade.DrawPicture();

            objFacade.DrawImage();

        }

    }

}

using System;

using System.Collections;

namespace 享元模式

{

    //Charactor

    public abstract class Charactor

    {

        protected char symbol;      //符号

        protected int width;        //宽度

        protected int height;       //高度

        protected int ascent;

        protected int descent;

        protected int pointSize;

        public abstract void SetPointSize(int size);

        public abstract void Display();

    }

    //Charactor A

    public class CharactorA : Charactor

    {

        public CharactorA()

        {

            this.symbol = 'A';

            this.width = 120;

            this.height = 100;

            this.ascent = 70;

            this.descent = 0;

        }

        public override void SetPointSize(int size)

        {

            this.pointSize = size;

        }

        public override void Display()

        {

            Console.WriteLine(this.symbol + "PointSize:" + this.pointSize);

        }

    }

    //Charactor B

    public class CharactorB : Charactor

    {

        public CharactorB()

        {

            this.symbol = 'B';

            this.width = 140;

            this.height = 100;

            this.ascent = 72;

            this.descent = 0;

        }

        public override void SetPointSize(int size)

        {

            this.pointSize = size;

        }

        public override void Display()

        {

            Console.WriteLine(this.symbol + "PointSize:" + this.pointSize);

        }

    }

    //Charactor C

    public class CharactorC : Charactor

    {

        public CharactorC()

        {

            this.symbol = 'C';

            this.width = 160;

            this.height = 100;

            this.ascent = 74;

            this.descent = 0;

        }

        public override void SetPointSize(int size)

        {

            this.pointSize = size;

        }

        public override void Display()

        {

            Console.WriteLine(this.symbol + "PointSize:" + this.pointSize);

        }

    }

    //CharactorFactory

    public class CharactorFactory

    {

        private Hashtable charactors = new Hashtable();

        private static CharactorFactory objCharactorFactory = null;

        private CharactorFactory()

        {

            this.charactors.Add("A", new CharactorA());

            this.charactors.Add("B", new CharactorB());

            this.charactors.Add("C", new CharactorC());

        }

        public static CharactorFactory Instance

        {

            get

            {

                if (objCharactorFactory == null)

                {

                    objCharactorFactory = new CharactorFactory();

                }

                return objCharactorFactory;

            }

        }

        public Charactor GetCharactor(string key)

        {

            Charactor objCharactor = this.charactors[key] as Charactor;

            if (objCharactor == null)

            {

                switch (key)

                {

                    case "A":

                        objCharactor = new CharactorA();

                        break;

                    case "B":

                        objCharactor = new CharactorB();

                        break;

                    case "C":

                        objCharactor = new CharactorC();

                        break;

                }

                this.charactors.Add(key, objCharactor);

            }

            return objCharactor;

        }

    }

    public class Test

    {

        public void TestMethod()

        {

            CharactorFactory objCharactorFactory = CharactorFactory.Instance;

            //Char A

            CharactorA objCharA = (CharactorA)objCharactorFactory.GetCharactor("A");

            objCharA.SetPointSize(12);

            objCharA.Display();

            //Char B

            CharactorB objCharB = (CharactorB)objCharactorFactory.GetCharactor("B");

            objCharB.SetPointSize(10);

            objCharB.Display();

            //Char C

            CharactorC objCharC = (CharactorC)objCharactorFactory.GetCharactor("C");

            objCharC.SetPointSize(14);

            objCharC.Display();

        }

    }

}

using System;

namespace 代理模式

{

    //抽象主题角色

    abstract class Subject

    {

        public abstract void Request();

    }

    //真实主题角色

    class RealSubject : Subject

    {

        public override void Request()

        {

            //RealSubject.Request();

        }

    }

    //代理主题角色

    class Proxy : Subject

    {

        private RealSubject objRealSubject = null;

        public override void Request()

        {

            if (this.objRealSubject == null)

            {

                this.objRealSubject = new RealSubject();

            }

            this.PreRequest();

            this.objRealSubject.Request();

            this.PostRequest();

        }

        public void PreRequest()

        {

            //PreRequest

        }

        public void PostRequest()

        {

            //PostRequest

        }

    }

    public class Test

    {

        public void TestMethod()

        {

            Proxy objProxy = new Proxy();

            objProxy.Request();

        }

    }

}

基本思想：

    每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

排序过程：

    初始关键字   [49 38 65 97 76 13 27 49]

    第一趟排序后 13 [38 65 97 76 49 27 49]

    第二趟排序后 13 27 [65 97 76 49 38 49]

    第三趟排序后 13 27 38 [97 76 49 65 49]

    第四趟排序后 13 27 38 49 [49 97 65 76]

    第五趟排序后 13 27 38 49 49 [97 97 76]

    第六趟排序后 13 27 38 49 49 76 [76 97]

    第七趟排序后 13 27 38 49 49 76 76 [97]

    最后排序结果 13 27 38 49 49 76 76 97

代码：

using System;

namespace 选择排序

{

    public class 选择排序

    {

        public static void Sort(int[] numbers)

        {

            int temp = 0;

            for (int index = 0; index < numbers.Length; index++)

            {

                for (int index2 = index + 1; index2 < numbers.Length; index2++)

                {

                    if (numbers[index]< numbers[index2])

                    {

                        temp = numbers[index2];

                        numbers[index2] = numbers[index];

                        numbers[index] = temp;

                    }

                }

            }

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            int[] numbers = { 9, 10, 8, 6, 20, 45, 0, 68};

            foreach (int temp in numbers)

            {

                Console.WriteLine(temp);

            }

            Console.WriteLine("\n\n");

            选择排序.Sort(numbers);

            foreach (int temp in numbers)

            {

                Console.WriteLine(temp);

            }

            Console.Read();

        }

    }

}

原理：

    在所给的N个数中，先拿第一个数和第二个比较，然后让较大的一个排在后面(即如果N1>N2，则让N1与N2交换位置)，然后又拿第二个数来和第三个数比较，又把较大的一个排在后面，如此往下做下去，直到第N-1个数和第N个数比较完后，最大的那个数就会被升到了最后面来。接下来又照同样的方法来把前N-1个数中最大的数排到第N-1的位置上，做到最后，整一列数都被排好了。

代码：

using System;

namespace 冒泡排序

{

    public class 冒泡排序

    {

        public static void Sort(int[] numbers)

        {

            int temp = 0;

            //控制比较次数

            for (int index = 0; index < numbers.Length - 1; index++)

            {

                for (int index2 = 0; index2 < numbers.Length - 1; index2++)

                {

                    if (numbers[index2] > numbers[index2 + 1])

                    {

                        temp = numbers[index2 + 1];

                        numbers[index2 + 1] = numbers[index2];

                        numbers[index2] = temp;

                    }

                }

            }

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            int[] numbers = { 9, 10, 8, 6, 20, 45, 0, 68};

            foreach (int temp in numbers)

            {

                Console.WriteLine(temp);

            }

            Console.WriteLine("\n\n");

            冒泡排序.Sort(numbers);

            foreach (int temp in numbers)

            {

                Console.WriteLine(temp);

            }

            Console.Read();

        }

    }

}